คำถามติดแท็ก asynchronous-programming

1
มีความแตกต่างพื้นฐานระหว่างการโทรกลับและสัญญาหรือไม่
เมื่อทำการเขียนโปรแกรมแบบอะซิงโครนัสแบบเธรดเดียวมีสองเทคนิคหลักที่ฉันคุ้นเคย ที่พบมากที่สุดคือการใช้การเรียกกลับ นั่นหมายถึงการส่งผ่านไปยังฟังก์ชั่นที่ทำหน้าที่โทรกลับ - ฟังก์ชั่นแบบอะซิงโครนัสเป็นพารามิเตอร์ เมื่อการดำเนินการแบบอะซิงโครนัสจะเสร็จสิ้นการเรียกกลับจะถูกเรียก jQueryรหัสทั่วไปบางอย่างออกแบบด้วยวิธีนี้: $.get('userDetails', {'name': 'joe'}, function(data) { $('#userAge').text(data.age); }); อย่างไรก็ตามโค้ดประเภทนี้สามารถทำให้เกิดความยุ่งเหยิงและซ้อนกันได้สูงเมื่อเราต้องการเรียก async เพิ่มเติมอีกอันหนึ่งเรียกอีกอย่างหนึ่งเมื่อรหัสก่อนหน้านี้เสร็จสิ้น ดังนั้นวิธีที่สองคือใช้สัญญา คำมั่นสัญญาเป็นวัตถุที่แสดงถึงค่าที่อาจยังไม่มี คุณสามารถตั้งค่า callback บนมันซึ่งจะถูกเรียกเมื่อค่าพร้อมที่จะอ่าน ความแตกต่างระหว่างคำสัญญาและวิธีการเรียกกลับแบบเดิมคือวิธีการแบบอะซิงก์ตอนนี้ส่งคืนออบเจ็กต์คำสัญญาซึ่งลูกค้าตั้งค่าการเรียกกลับ ตัวอย่างเช่นรหัสที่คล้ายกันโดยใช้สัญญาใน AngularJS: $http.get('userDetails', {'name': 'joe'}) .then(function(response) { $('#userAge').text(response.age); }); ดังนั้นคำถามของฉันคือจริง ๆ แล้วมีความแตกต่างจริง ๆ ความแตกต่างนั้นดูเหมือนจะเป็นการสร้างประโยคอย่างหมดจด มีเหตุผลใดที่ลึกซึ้งยิ่งขึ้นในการใช้เทคนิคหนึ่งเหนืออีกเทคนิคหนึ่ง?

8
กิจกรรมใช้สำหรับการเขียนโปรแกรม GUI เท่านั้นหรือไม่
กิจกรรมใช้สำหรับการเขียนโปรแกรม GUI เท่านั้นหรือไม่ คุณจัดการกับการเขียนโปรแกรมแบ็กเอนด์ปกติอย่างไรเมื่อมีบางอย่างเกิดขึ้นกับสิ่งอื่นนี้

13
ทำไมภาษาโปรแกรมไม่จัดการปัญหาซิงโครนัส / อะซิงโครนัสโดยอัตโนมัติ?
ฉันไม่ได้พบแหล่งข้อมูลมากมายเกี่ยวกับสิ่งนี้: ฉันสงสัยว่ามันเป็นไปได้ / เป็นความคิดที่ดีที่จะสามารถเขียนโค้ดแบบอะซิงโครนัสในแบบซิงโครนัส ตัวอย่างเช่นนี่คือโค้ด JavaScript บางอย่างที่ดึงจำนวนผู้ใช้ที่เก็บในฐานข้อมูล (การดำเนินการแบบอะซิงโครนัส): getNbOfUsers(function (nbOfUsers) { console.log(nbOfUsers) }); มันคงจะดีถ้าได้เขียนอะไรแบบนี้: const nbOfUsers = getNbOfUsers(); console.log(getNbOfUsers); console.logและเพื่อให้คอมไพเลอร์โดยอัตโนมัติจะดูแลการรอคอยสำหรับการตอบสนองแล้วรัน มันจะรอให้การดำเนินการแบบอะซิงโครนัสเสร็จสมบูรณ์ก่อนที่ผลลัพธ์จะต้องถูกนำไปใช้ที่อื่น เราจะใช้สัญญาการติดต่อกลับน้อยลงอย่างมาก async / รอหรืออะไรก็ตามและไม่ต้องกังวลว่าผลลัพธ์ของการดำเนินการจะพร้อมใช้งานทันทีหรือไม่ ข้อผิดพลาดจะยังคงสามารถจัดการได้ (ได้nbOfUsersรับจำนวนเต็มหรือข้อผิดพลาด?) โดยใช้ลอง / จับหรือสิ่งที่ชอบตัวเลือกเช่นในภาษาสวิฟท์ มันเป็นไปได้? มันอาจเป็นความคิดที่น่ากลัว / ยูโทเปีย ... ฉันไม่รู้

4
อะไรเป็นตัวกำหนดว่าฟังก์ชั่น Javascript ใดบ้างที่ถูกบล็อกเทียบกับการไม่บล็อก?
ฉันได้ทำ Javascript บนเว็บ (วานิลลา JS, jQuery, Backbone ฯลฯ ) มาหลายปีแล้วและเมื่อไม่นานมานี้ฉันได้ทำงานกับ Node.js ฉันใช้เวลาสักครู่เพื่อหยุดการเขียนโปรแกรม "non-blocking" แต่ตอนนี้ฉันคุ้นเคยกับการใช้ callback สำหรับการดำเนินการ IO และอะไรก็ตาม ฉันเข้าใจว่า Javascript นั้นเป็นเธรดเดียวโดยธรรมชาติ ฉันเข้าใจแนวคิดของโหนด "คิวเหตุการณ์" สิ่งที่ฉันไม่เข้าใจคือสิ่งที่กำหนดว่าการดำเนินการจาวาสคริปต์แต่ละรายการนั้นคือ "การบล็อก" กับ "การไม่บล็อก" ฉันจะทราบได้อย่างไรว่าการดำเนินการใดที่ฉันสามารถพึ่งพาเพื่อสร้างเอาต์พุตแบบซิงโครนัสสำหรับฉันที่จะใช้ในโค้ดในภายหลังและอันไหนที่ฉันจะต้องผ่านการเรียกกลับเพื่อให้ฉันสามารถประมวลผลเอาท์พุทได้ มีรายการฟังก์ชั่น Javascript ที่อื่นที่ไม่ตรงกัน / ไม่บล็อกและรายการของฟังก์ชันที่ซิงโครนัส / บล็อกหรือไม่ อะไรที่ทำให้แอพ Javascript ของฉันไม่เป็นหนึ่งในการแข่งขันที่ยิ่งใหญ่ ฉันรู้ว่าการดำเนินการที่ใช้เวลานานเช่นการปฏิบัติการ IO ในการดำเนินงาน Node และ AJAX บนเว็บต้องการให้มีการแบบอะซิงโครนัสดังนั้นจึงใช้การเรียกกลับ - แต่ใครจะพิจารณาว่าคุณสมบัติใดเป็น "เวลานาน"? มีการจัดเรียงของทริกเกอร์ภายในการดำเนินการเหล่านี้ที่ลบออกจาก "คิวเหตุการณ์" …

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

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

1
การเรียนรู้การโปรแกรมแบบอะซิงโครนัส [ปิด]
ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัพเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว การเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์แบบไม่บล็อกไม่ตรงกันดูเหมือนว่าจะเป็นความโกรธทั้งหมด ฉันมีความเข้าใจแนวคิดพื้นฐานเกี่ยวกับความหมายทั้งหมดนี้ อย่างไรก็ตามสิ่งที่ฉันไม่แน่ใจคือเมื่อใดและรหัสของฉันจะได้ประโยชน์จากการเป็นแบบอะซิงโครนัสหรือวิธีการบล็อก IO การไม่บล็อก ฉันแน่ใจว่าฉันสามารถใช้ห้องสมุดเพื่อทำสิ่งนี้ได้ แต่ฉันสนใจในแนวคิดเชิงลึกมากขึ้นและวิธีการต่าง ๆ ในการนำมันมาใช้เอง มีหนังสือที่ครอบคลุม / แตกหักหรือแหล่งข้อมูลอื่น ๆ ในเรื่องนี้ (เช่นGoFสำหรับรูปแบบการออกแบบหรือK&Rสำหรับ C, tldpสำหรับสิ่งต่าง ๆ เช่นทุบตี) (หมายเหตุ: ฉันไม่แน่ใจว่านี่เป็นคำถามที่ตรงกับคำถามของฉันในการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์การเรียนรู้หรือไม่ )

2
ใครทำ async / รอก่อน
Python เพิ่ม async / await constructs ใน 3.5 ในปี 2015 ชุมชน Javascript ได้ทำตามขั้นตอนมาเป็นเวลากว่าพันล้านปีและในที่สุดก็เพิ่มการใช้งานที่คล้ายกันมากกับร่างใน ES8 ที่เปิดตัวในปี 2017 (จากความเข้าใจของฉัน) typescript ยังเพิ่มวิธีการ async ในปี 2015 ในรุ่น 1.7 ที่ดวงตาที่ไม่ได้รับการฝึกฝนดูเหมือนว่าวิธี js async C # วิธีการเพิ่ม async ในปี 2012 ที่ดูเหมือนว่าการใช้งานอื่น ๆ ของ async / await และขึ้นอยู่กับการทำงานที่คล้ายกันของ F # แต่เวิร์กโฟลว์แบบอะซิงโครนัสที่ดูแตกต่างกันซึ่งถูกนำมาใช้ใน F # 2.0 ในปี 2010 นี่เป็นตัวอย่างแรกสุด - …

1
Akka obsolesce โบรกเกอร์ข้อความ JMS / AMQP หรือไม่ [ปิด]
ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันใช้เวลาหนึ่งสัปดาห์ในการดำน้ำลึกเข้าไปในเอกสาร Akkaและในที่สุดก็เข้าใจว่าระบบของนักแสดงคืออะไรและปัญหาที่พวกเขาแก้ไข ความเข้าใจของฉัน(และประสบการณ์กับ) โบรกเกอร์ข้อความ JMS / AMQP ดั้งเดิมคือพวกเขามีตัวตนเพื่อให้สิ่งต่อไปนี้: การประมวลผลแบบอะซิงโครนัสระหว่างผู้ผลิตและผู้บริโภค และ การรับประกันการส่งข้อความรวมถึงการคงอยู่การลองใหม่และการย้อนกลับ แต่ Akka ไม่ได้ให้สิ่งนี้โดยไม่มีโครงสร้างพื้นฐานที่จำเป็นและค่าใช้จ่ายในการดำเนินงานทั้งหมดหรือไม่ ใน Akka การสื่อสารของนักแสดงทั้งหมดไม่ตรงกันและไม่ปิดกั้น และ ใน Akka SupervisorStrategiesมีอยู่เพื่อบรรลุการลองใหม่อีกครั้งทางเลือกและการเพิ่มระดับ นักแสดงสามารถกำหนดค่าให้คงอยู่กับร้านค้าแทบทุกประเภทหากเป็นข้อกำหนดเช่นกัน นี่ทำให้ฉันสงสัยว่า: หากแอปของฉันใช้ Akka ฉันจำเป็นต้องนำโบรกเกอร์ JMS / AMQP (เช่น ActiveMQ, RabbitMQ, Kafka) เข้ามาในรูปภาพหรือไม่? กล่าวอีกนัยหนึ่งเคยมีกรณีการใช้งานที่แอพที่ใช้ Akka ใหม่จะรับประกันการเปิดตัวของกลุ่มโบรกเกอร์ JMS / AMQP ใหม่หรือไม่ ทำไมหรือทำไมไม่? อาร์กิวเมนต์เดียวอาจเป็นได้ว่าแอป …

3
การเรียกใช้บริการ async หลายตัวพร้อมกัน
ฉันมีบริการ async REST ไม่กี่รายการซึ่งไม่ได้ขึ้นอยู่กับกันและกัน นั่นคือในขณะที่ "รอ" คำตอบจาก Service1 ฉันสามารถโทร Service2, Service3 และอื่น ๆ ตัวอย่างเช่นอ้างถึงรหัสด้านล่าง: var service1Response = await HttpService1Async(); var service2Response = await HttpService2Async(); // Use service1Response and service2Response ตอนนี้service2Responseไม่ได้ขึ้นอยู่กับservice1Responseพวกเขาและสามารถดึงข้อมูลได้อย่างอิสระ ดังนั้นฉันไม่จำเป็นต้องรอการตอบรับจากบริการแรกเพื่อเรียกบริการที่สอง ฉันไม่คิดว่าฉันสามารถใช้Parallel.ForEachที่นี่ได้เนื่องจากไม่ใช่การทำงานของ CPU bound ในการเรียกการดำเนินการสองอย่างนี้แบบขนานฉันสามารถใช้งานได้Task.WhenAllไหม ปัญหาหนึ่งที่ฉันเห็นการใช้Task.WhenAllคือมันไม่ส่งคืนผลลัพธ์ ในการรับผลลัพธ์ฉันสามารถโทรtask.ResultหลังจากโทรTask.WhenAllได้เนื่องจากงานทั้งหมดเสร็จสมบูรณ์แล้วและสิ่งที่ฉันต้องใช้ในการตอบกลับคืออะไร? รหัสตัวอย่าง: var task1 = HttpService1Async(); var task2 = HttpService2Async(); await Task.WhenAll(task1, task2) var …

3
API Gateway (REST) ​​+ Microservices ที่ขับเคลื่อนด้วยเหตุการณ์
ฉันมี microservices มากมายที่มีฟังก์ชั่นที่ฉันเปิดเผยผ่าน REST API ตามรูปแบบเกตเวย์ API เนื่องจาก microservices เหล่านี้เป็นแอปพลิเคชั่น Spring Boot ฉันจึงใช้ Spring AMQP เพื่อให้เกิดการสื่อสารแบบซิงโครนัสสไตล์ RPC ระหว่างไมโครไซต์เหล่านี้ สิ่งต่าง ๆ ราบรื่นไปแล้ว อย่างไรก็ตามยิ่งฉันอ่านเกี่ยวกับสถาปัตยกรรม microservice ที่ขับเคลื่อนด้วยเหตุการณ์มากขึ้นและดูโครงการเช่น Spring Cloud Stream ยิ่งฉันเชื่อมั่นมากขึ้นว่าฉันอาจทำสิ่งที่ผิดกับ RPC วิธีการแบบซิงโครนัส เพื่อตอบสนองการร้องขอนับร้อยหรือพันต่อวินาทีจากแอปพลิเคชันไคลเอนต์) ฉันเข้าใจจุดหลังสถาปัตยกรรมที่ขับเคลื่อนด้วยเหตุการณ์ สิ่งที่ฉันไม่ค่อยเข้าใจคือวิธีการใช้รูปแบบดังกล่าวจริงเมื่อนั่งอยู่ข้างหลังแบบจำลอง (REST) ​​ที่คาดว่าจะตอบสนองต่อทุกคำขอ ตัวอย่างเช่นถ้าฉันมีเกตเวย์ API เป็น microservice และอีกบริการหนึ่งที่เก็บและจัดการผู้ใช้ฉันจะสร้างแบบจำลองเช่นGET /users/1ในเหตุการณ์ที่ขับเคลื่อนด้วยเหตุการณ์ได้อย่างหมดจดได้อย่างไร

1
NodeJS จะ“ ไม่ปิดกั้น” ได้อย่างไร?
ฉันกำลังเรียนรู้ NodeJS และแค่ต้องการชี้แจงบางอย่าง ในแบบฝึกหัดเบื้องต้นและหนังสือหลายเล่มจนถึงตอนต้นพวกเขาได้อธิบายสถาปัตยกรรม "ไม่บล็อก" ของโหนดหรือค่อนข้างเป็นไปได้ (และแนะนำทั้งจุด) เป็นรหัสในลักษณะที่ไม่ปิดกั้น ตัวอย่างเช่นตัวอย่างนี้มีให้ในหนังสือที่ฉันกำลังอ่านวิธีอะซิงโครนัสเพื่อรับข้อมูลจากฐานข้อมูล http.createServer(function (req, res) { database.getInformation(function (data) { res.writeHead(200); res.end(data); }); }); เกิดอะไรขึ้น (ตามที่ฉันเข้าใจ) คือโหนดทำให้การเรียกไปยังฐานข้อมูลจากนั้นดำเนินการสิ่งที่อาจเกิดขึ้นต่อไปในสแต็คการโทร เมื่อการร้องขอฐานข้อมูลเสร็จสมบูรณ์ตัวแปรข้อมูลในฟังก์ชั่นการโทรกลับที่ไม่ระบุชื่อจะถูกเติมและฟังก์ชั่นนั้นจะถูกเพิ่มเข้าไปในสแต็คการโทร (และดำเนินการในภายหลังเมื่อโหนดเข้าสู่มัน) คำถามของฉันคือการประมวลผลการร้องขอฐานข้อมูลคืออะไร? แน่นอนโหนดต้องปิดกั้นในขณะที่มันทำอย่างนั้น? การดูแลคำขอฐานข้อมูลคืออะไร หรือถ้าโหนดกำลังรอการร้องขอ HTTP GET แบบอะซิงโครนัสไปยังทรัพยากรภายนอกสิ่งที่ดูแลคำขอนั้นที่อนุญาตให้โหนดประมวลผลสแต็กการโทรต่อและเป็น "non-blocking"

2
การผสมวิธีการซิงค์และ async มีประสิทธิภาพภายในวิธีการเดียวหรือไม่
โอเคฟังดูแปลก แต่รหัสนั้นง่ายมากและอธิบายสถานการณ์ได้ดี public virtual async Task RemoveFromRoleAsync(AzureTableUser user, string role) { AssertNotDisposed(); var roles = await GetRolesForUser(user); roles.Roles = RemoveRoles(roles.Roles, role); await Run(TableOperation.Replace(roles)); } (ฉันรู้ว่าฉันกำลังพูดถึงในบทคัดย่อด้านล่าง แต่ข้างต้นเป็นวิธีการที่เกิดขึ้นจริงจากสิ่งที่จะเป็นรหัสการผลิตจริงที่ทำในสิ่งที่ฉันถามเกี่ยวกับที่นี่และฉันสนใจในการตรวจสอบจริงของคุณ เพื่อความถูกต้องโปรดดูรูปแบบ async / await) ฉันพบรูปแบบนี้บ่อยขึ้นเรื่อย ๆ ในขณะที่ฉันกำลังใช้async/ awaitมากกว่า รูปแบบประกอบด้วยห่วงโซ่ของเหตุการณ์ต่อไปนี้: รอสายแรกที่ทำให้ฉันได้รับข้อมูลบางอย่างที่ฉันต้องทำ ทำงานกับข้อมูลนั้นพร้อมกัน รอสายสุดท้ายที่บันทึกงานที่อัปเดต โดยทั่วไปโค้ดบล็อกด้านบนเป็นวิธีที่ฉันใช้จัดการวิธีการเหล่านี้ ฉันawaitโทรครั้งแรกซึ่งฉันต้องทำเพราะมันเป็นแบบอะซิงโครนัส ต่อไปฉันทำงานที่ฉันต้องทำซึ่งไม่ใช่ IO หรือทรัพยากรถูกผูกไว้และไม่ใช่ async สุดท้ายผมบันทึกการทำงานของฉันซึ่งยังเป็นผู้asyncโทรเข้าและออกของสินค้าลัทธิผมawaitมัน แต่นี่เป็นวิธีที่มีประสิทธิภาพ / ถูกที่สุดในการจัดการรูปแบบนี้หรือไม่? ดูเหมือนว่าฉันจะสามารถข้ามawaitสายสุดท้ายได้ แต่จะเกิดอะไรขึ้นถ้ามันล้มเหลว …

1
เบลอเส้นระหว่างแอซิงก์และฟังก์ชั่นปกติใน C # 5.0
เมื่อเร็ว ๆ นี้ดูเหมือนว่าฉันจะไม่สามารถรับรูปแบบasync-await ที่น่าทึ่งของ C # 5.0 ได้ คุณอยู่ที่ไหนตลอดชีวิตของฉัน ฉันตื่นเต้นอย่างมากกับไวยากรณ์ที่เรียบง่าย แต่ฉันมีปัญหาเล็กน้อย ปัญหาของฉันคือฟังก์ชั่น async มีการประกาศที่แตกต่างกันโดยสิ้นเชิงจากฟังก์ชั่นปกติ เนื่องจากมีเพียง async เท่านั้นที่สามารถรอฟังก์ชั่นอื่น ๆ ของ async ได้เมื่อฉันพยายามที่จะแปลงรหัสการบล็อกเก่า ๆ ให้เป็น async ฉันจึงมีผลกระทบโดมิโนของฟังก์ชั่นที่ฉันต้องแปลง คนได้รับการอ้างถึงนี้เป็นทำลายผีดิบ เมื่อ async เริ่มกัดรหัสของคุณมันก็จะยิ่งใหญ่ขึ้นเรื่อย ๆ กระบวนการ porting ไม่ยากมันเป็นเพียงแค่การขว้างปาในการประกาศและการตัดค่าตอบแทนด้วยasync Task<>แต่มันเป็นเรื่องที่น่ารำคาญที่จะทำเช่นนี้ซ้ำแล้วซ้ำอีกเมื่อทำการพอร์ตรหัสซิงโครนัสเก่า ดูเหมือนว่าฉันจะเป็นธรรมชาติมากขึ้นถ้าทั้งสองประเภทฟังก์ชั่น (async และซิงค์เก่าธรรมดา) มีไวยากรณ์เดียวกันแน่นอน หากเป็นกรณีนี้การย้ายจะใช้ความพยายามเป็นศูนย์และฉันสามารถสลับระหว่างสองรูปแบบได้อย่างไม่ลำบาก ฉันคิดว่าสิ่งนี้สามารถใช้งานได้หากเราปฏิบัติตามกฎเหล่านี้: ฟังก์ชัน Async ไม่จำเป็นต้องมีการasyncประกาศอีกต่อไป Task<>ประเภทการกลับมาของพวกเขาจะได้ไม่ต้องถูกห่อใน คอมไพเลอร์จะระบุฟังก์ชั่น async ระหว่างการคอมไพล์ด้วยตัวเองและทำการตัดคำสั่งงาน <> โดยอัตโนมัติตามต้องการ ไม่มีการเรียกและฟังก์ชั่น …

1
เมื่องานอะซิงโครนัสทำให้ UX ไม่ดี
ฉันกำลังเขียน COM add-in ที่ขยาย IDE ที่ต้องการอย่างยิ่ง มีคุณสมบัติหลายอย่างที่เกี่ยวข้อง แต่ให้แคบลงเป็น 2 เพื่อประโยชน์ของโพสต์นี้: มีเครื่องมือExplorer ในหน้าต่างที่แสดงมุมมองแบบต้นไม้ที่ช่วยให้ผู้ใช้นำทางโมดูลและสมาชิกของพวกเขา มีเครื่องมือตรวจสอบรหัสหน้าต่างที่แสดงDataGridviewที่ให้ผู้ใช้สำรวจปัญหารหัสและแก้ไขให้โดยอัตโนมัติ เครื่องมือทั้งสองมีปุ่ม "รีเฟรช" ที่เริ่มงานแบบอะซิงโครนัสที่แยกวิเคราะห์รหัสทั้งหมดในโครงการที่เปิดอยู่ทั้งหมด รหัส Explorer ที่ใช้ผลการแจงการสร้างTreeViewและรหัสการตรวจสอบการใช้ผลการแจงที่จะพบปัญหารหัสและแสดงผลลัพธ์ในของDataGridView สิ่งที่ฉันพยายามที่จะทำที่นี่คือการแบ่งปันผลแยกระหว่างคุณสมบัติเพื่อที่ว่าเมื่อรหัส Explorer ในการรีเฟรชแล้วรหัสการตรวจสอบรู้เกี่ยวกับมันและสามารถฟื้นฟูตัวเองได้โดยไม่ต้องทำซ้ำการทำงานแยกว่ารหัส Explorer ที่ก็ไม่ได้ . ดังนั้นสิ่งที่ฉันทำฉันทำให้ parser class เป็นผู้ให้บริการเหตุการณ์ที่คุณสมบัติสามารถลงทะเบียนได้ที่: private void _parser_ParseCompleted(object sender, ParseCompletedEventArgs e) { Control.Invoke((MethodInvoker) delegate { Control.SolutionTree.Nodes.Clear(); foreach (var result in e.ParseResults) { var node = new …
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.