ในเวอร์ชันใหม่ของ 1C:Enterprise การกำหนดค่าระบบ ฟังก์ชันและขั้นตอนต่างๆ มากมายได้ย้ายจากโมดูลอ็อบเจ็กต์ (เอกสาร ไดเร็กทอรี ฯลฯ) ไปยังโมดูลผู้จัดการ มาดูความแตกต่างระหว่างสองโมดูลนี้กัน
ตามทฤษฎีของการเขียนโปรแกรมเชิงวัตถุ วิธีการของวัตถุแบ่งออกเป็นสองกลุ่ม: แบบคงที่และแบบง่าย วิธีการง่าย ๆ มีสิทธิ์เข้าถึงอินสแตนซ์เฉพาะของคลาสเท่านั้น วิธีการแบบคงที่ไม่สามารถเข้าถึงข้อมูลอ็อบเจ็กต์ แต่ใช้งานได้กับคลาสโดยรวม
หากเราแปลทั้งหมดนี้ให้อยู่ในเงื่อนไขของระบบ 1C:Enterprise แล้วล่ะก็ โมดูลวัตถุประกอบด้วยวิธีการง่ายๆ หากต้องการใช้งาน คุณต้องได้รับออบเจ็กต์เฉพาะก่อน: องค์ประกอบของไดเร็กทอรี เอกสาร ฯลฯ โมดูลผู้จัดการมีวิธีการแบบคงที่ หากต้องการใช้งาน ไม่จำเป็นต้องแยกวัตถุแต่ละชิ้นออกจากกัน ช่วยให้คุณสามารถทำงานกับคอลเลกชันทั้งหมดได้ในคราวเดียว
โมดูลวัตถุอาจมีขั้นตอนและฟังก์ชั่นที่สามารถใช้ภายนอกได้ เพื่อจุดประสงค์นี้ขั้นตอนหรือฟังก์ชันดังกล่าวจะแสดงด้วยคำว่า ส่งออก.
ฟังก์ชัน NewFunction() ส่งออก
ในการใช้ฟังก์ชันดังกล่าวจากโมดูลออบเจ็กต์ คุณต้องมีลิงก์ไปยังออบเจ็กต์ที่ต้องการก่อน จากนั้นรับมันโดยใช้ฟังก์ชัน รับวัตถุ().
ต่อ= วัตถุ ฟังก์ชั่นใหม่() ;
ในทำนองเดียวกัน คุณสามารถสร้างตัวแปรใหม่ที่สามารถใช้ได้จากออบเจ็กต์การกำหนดค่าต่างๆ
ตัวแปรส่งออกตัวแปรใหม่
องค์ประกอบไดเรกทอรี = ไดเรกทอรี ศัพท์. FindByCode("000000001" ) ;
วัตถุ = องค์ประกอบไดเรกทอรี GetObject() ;
วัตถุ. ตัวแปรใหม่= ) ;
ด้วยวิธีนี้ คุณสามารถเสริมขั้นตอนมาตรฐาน ฟังก์ชัน และคุณสมบัติ (ตัวแปร) ของออบเจ็กต์ได้ ตัวแปรดังกล่าวเป็นแบบไดนามิก โดยจะไม่ถูกบันทึกในฐานข้อมูลและมีอยู่เฉพาะในขณะที่ทำงานกับออบเจ็กต์ที่ได้รับเท่านั้น
โมดูลผู้จัดการมีความสามารถเหมือนกันทั้งหมด ข้อแตกต่างเพียงอย่างเดียวคือในการใช้งานคุณไม่จำเป็นต้องได้รับวัตถุเฉพาะ โมดูลตัวจัดการช่วยให้คุณสามารถทำงานกับคอลเลกชันทั้งหมดของวัตถุบางประเภทได้
ขั้นตอน NewProcedure() ส่งออก
องค์ประกอบไดเรกทอรี = ไดเรกทอรี ศัพท์. ขั้นตอนใหม่();
หรือสำหรับตัวแปร:
ตัวแปรส่งออกตัวแปรใหม่
องค์ประกอบไดเรกทอรี = ไดเรกทอรี ศัพท์. ตัวแปรใหม่;
มาดูความแตกต่างในการใช้โมดูลอ็อบเจ็กต์และโมดูลตัวจัดการโดยใช้ตัวอย่างของขั้นตอนการสร้างแบบฟอร์มที่พิมพ์ของเอกสาร
เมื่อใช้โมดูลวัตถุ โค้ดจะมีลักษณะดังนี้:
ฟังก์ชั่นการพิมพ์เอกสาร (ลิงก์) ส่งออก
//คุณต้องส่งลิงก์ไปยังเอกสารเฉพาะไปยังฟังก์ชันนี้
กลับ TabDoc;
EndFunction
บนแบบฟอร์มเอกสาร คุณต้องสร้างขั้นตอนที่จะส่งลิงก์ไปยังเอกสารไปยังฟังก์ชันการพิมพ์
&บนไคลเอนต์
ขั้นตอนการพิมพ์(คำสั่ง)
TabDoc = PrintOnServer();
แท็บด็อก. แสดง() ;
สิ้นสุดขั้นตอน
&บนเซิร์ฟเวอร์
ฟังก์ชั่น PrintOnServer()
Doc = FormAttributesValue("วัตถุ" ) ;
กลับหมอ พิมพ์เอกสาร(Object.Link);
EndFunction
ข้อเสียของวิธีนี้คือพิมพ์ได้เพียงวัตถุเดียวเท่านั้น หากคุณต้องการพิมพ์เอกสารหลายฉบับในคราวเดียว คุณจะต้องได้รับเอกสารแต่ละฉบับ จากนั้นเรียกใช้ฟังก์ชันจากโมดูลอ็อบเจ็กต์ ซึ่งต้องใช้ทรัพยากรระบบที่สำคัญเนื่องจากเมื่อวัตถุถูกดึงข้อมูล วัตถุทั้งหมดจะถูกวางใน RAM
จากจุดยืนด้านประสิทธิภาพ การใช้โมดูลตัวจัดการทุกครั้งที่เป็นไปได้จะดีกว่ามาก ในตัวอย่างของเรา วิธีแก้ไขปัญหาจะมีลักษณะเช่นนี้
ฟังก์ชั่น PrintOnServer()
เอกสารส่งคืน. เอกสารของเรา. พิมพ์เอกสาร(ArrayLinks);
EndFunction
หากคุณใช้โมดูลตัวจัดการ ขั้นตอนการพิมพ์สามารถเรียกได้ทั้งจากแบบฟอร์มเอกสารและจากแบบฟอร์มรายการ โดยส่งลิงก์ไปยังเอกสารหลายฉบับในอาร์เรย์ ในกรณีนี้ ระบบไม่จำเป็นต้องได้รับแต่ละเอกสารจากอาเรย์ ซึ่งช่วยประหยัดทรัพยากรระบบได้อย่างมาก
ดังนั้นเมื่อใดควรใช้โมดูลอ็อบเจ็กต์ และเมื่อใดจึงควรใช้โมดูลตัวจัดการ
ทุกอย่างขึ้นอยู่กับงาน หากการอ้างอิงถึงอ็อบเจ็กต์เพียงพอที่จะทำให้เสร็จสมบูรณ์ (เช่น งานพิมพ์) ควรใช้โมดูลตัวจัดการจะดีกว่า หากงานคือการเปลี่ยนแปลงข้อมูล เช่น กรอกเอกสาร คุณจะต้องรับและใช้โมดูลอ็อบเจ็กต์
บทความนี้ยังคงดำเนินต่อไปในซีรีส์ "ขั้นตอนแรกในการพัฒนา 1C" โดยจะกล่าวถึงรายละเอียดประเด็นต่อไปนี้:
- โมดูลซอฟต์แวร์คืออะไร และประกอบด้วยส่วนใดบ้าง
- โมดูลแอปพลิเคชันมีไว้เพื่ออะไร? ทำไมถึงมีสองคนล่ะ? ตัวไหนเปิดตัวเมื่อไร? รายละเอียดปลีกย่อยของงานมีอะไรบ้าง?
- เหตุการณ์ใดบ้างที่เกี่ยวข้องกับการเริ่มการทำงานของระบบ วิธีและวิธีประมวลผลเหตุการณ์เหล่านั้น?
- โมดูลการเชื่อมต่อภายนอกมีไว้เพื่ออะไร? จะใช้เมื่อใดและอย่างไร?
- โมดูลเซสชันจะใช้เมื่อใด
- โมดูลทั่วไปคืออะไร? คุณสมบัติและกฎการดำเนินงานคืออะไร? เหตุใดจึงใช้คุณสมบัติ "การนำค่าที่ส่งคืนมาใช้ซ้ำ"
- โมดูลฟอร์มจะใช้เมื่อใดและสามารถประมวลผลเหตุการณ์ใดได้บ้าง
- โมดูลวัตถุมีไว้เพื่ออะไร? ประกอบด้วยส่วนใดบ้าง? ฉันจะดูเหตุการณ์โมดูลที่มีอยู่ได้อย่างไร
- รายละเอียดปลีกย่อยของการทำงานกับโมดูลตัวจัดการค่า (สำหรับค่าคงที่) และโมดูลชุดระเบียน (สำหรับรีจิสเตอร์) คืออะไร
- อะไรคือความแตกต่างระหว่างโมดูลอ็อบเจ็กต์และโมดูลผู้จัดการ? เมื่อใดที่คุณควรใช้อย่างหลัง?
การบังคับใช้
บทความนี้กล่าวถึงแพลตฟอร์ม 1C:Enterprise 8.3.4.496 เนื้อหานี้ยังเกี่ยวข้องกับการเผยแพร่แพลตฟอร์มในปัจจุบันด้วย
โมดูลใน "1C:Enterprise 8.3"
โมดูลคืออ็อบเจ็กต์ที่มีโค้ดโปรแกรม
มีโมดูลหลายประเภทในแพลตฟอร์มค่อนข้างมาก ซึ่งแต่ละประเภทมีวัตถุประสงค์และคุณสมบัติของตัวเอง
บรรทัดโค้ดใดๆ จะต้องอยู่ในบางโมดูล มีโมดูลเอนกประสงค์และโมดูลอ็อบเจ็กต์ บางโมดูลสามารถคอมไพล์ได้ทั้งบนไคลเอนต์และเซิร์ฟเวอร์ และบางโมดูลบนเซิร์ฟเวอร์เท่านั้น
โมดูลอาจประกอบด้วยหลายส่วน ส่วนคำอธิบายตัวแปรจะอธิบายตัวแปรภายในเครื่องของโมดูลนี้ ซึ่งสามารถนำมาใช้ในขั้นตอนใดก็ได้ในภายหลัง
ภายในแต่ละขั้นตอน คุณสามารถเข้าถึงตัวแปรโมดูลได้ นอกจากนี้ ภายในโพรซีเดอร์เองอาจมีการประกาศตัวแปรอื่นที่มีชื่อเดียวกัน นี่จะเป็นตัวแปรภายในเครื่องของขั้นตอนนี้
แม้จะมีชื่อเดียวกัน แต่ก็มีตัวแปรสองตัวที่แตกต่างกัน: ตัวหนึ่งถูกใช้ภายในขั้นตอนเฉพาะ และอีกตัวถูกใช้ภายนอก
ในบางโมดูล ตัวแปรอาจระบุตำแหน่งของการคอมไพล์ (ความพร้อมใช้งาน) บนเซิร์ฟเวอร์หรือบนไคลเอนต์ ตัวอย่างเช่น:
ส่วนที่อธิบายตัวแปรจะตามมาด้วยส่วนของขั้นตอนและฟังก์ชัน โดยระบุวิธีการเฉพาะของโมดูลนี้ บางโมดูลต้องระบุตำแหน่งที่จะรวบรวมขั้นตอนหรือฟังก์ชัน
โดยหลักการแล้ว สามารถละเว้นคำสั่งการคอมไพล์ได้ ในกรณีนี้ คำสั่งการคอมไพล์เริ่มต้นคือเซิร์ฟเวอร์ อย่างไรก็ตาม เพื่อความสะดวกในการวิเคราะห์โค้ดโปรแกรม แนะนำให้ระบุอย่างชัดเจนว่าขั้นตอนที่กำหนดจะถูกคอมไพล์ที่ใด ลำดับของการอธิบายขั้นตอนไม่สำคัญ
ในตอนท้ายของโมดูล หลังจากอธิบายขั้นตอนและฟังก์ชันทั้งหมดแล้ว จะมีส่วนของโปรแกรมหลัก ซึ่งสามารถประกอบด้วยตัวดำเนินการบางตัวและเริ่มต้นตัวแปรภายในเครื่องของโมดูลฟอร์ม ส่วนนี้จะดำเนินการเมื่อเข้าถึงโมดูล
ตัวอย่างเช่น เมื่อเปิดแบบฟอร์มองค์ประกอบ ส่วนโปรแกรมหลักของโมดูลแบบฟอร์มจะถูกดำเนินการก่อน
ควรสังเกตว่าส่วนการประกาศตัวแปรและส่วนโปรแกรมหลักไม่มีอยู่สำหรับทุกโมดูล (เช่น ส่วนเหล่านี้ไม่ถูกต้องในบางโมดูล) ส่วนสำหรับอธิบายขั้นตอนและฟังก์ชันสามารถมีอยู่ในโมดูลใดก็ได้
โมดูลแอปพลิเคชัน
โมดูลนี้ออกแบบมาเพื่อจัดการกับเหตุการณ์การเริ่มต้นและการยกเลิกแอปพลิเคชัน ตัวอย่างเช่น เมื่อคุณเปิดแอปพลิเคชัน คุณสามารถดาวน์โหลดอัตราสกุลเงินจากอินเทอร์เน็ตได้ เมื่อยกเลิกแอปพลิเคชัน คุณสามารถยืนยันกับผู้ใช้ได้ว่าเขาหรือเธอตั้งใจที่จะออก
นอกจากนี้ในโมดูลแอปพลิเคชันยังมีตัวจัดการพิเศษที่ช่วยให้คุณสามารถสกัดกั้นเหตุการณ์ภายนอกจากอุปกรณ์ได้
เหตุการณ์เหล่านี้อาจเป็นเหตุการณ์จากเครื่องอ่านบัตรแม่เหล็กหรือนายทะเบียนทางการเงิน และเหตุการณ์เหล่านี้ก็สามารถประมวลผลได้ไม่ทางใดก็ทางหนึ่ง
โปรดทราบว่าเป็นการเริ่มต้นระบบแบบโต้ตอบที่ได้รับการตรวจสอบในโมดูลแอปพลิเคชัน
โมดูลแอปพลิเคชันจะไม่ทำงานหากเปิดโปรแกรม 1C เช่นในโหมดการเชื่อมต่อ com ในกรณีนี้ หน้าต่างโปรแกรมจะไม่ถูกสร้างขึ้น
ควรสังเกตว่าในแพลตฟอร์ม 8.3 มีโมดูลแอปพลิเคชันที่แตกต่างกันสองโมดูล: โมดูลแอปพลิเคชันที่ได้รับการจัดการและโมดูลแอปพลิเคชันทั่วไป เหตุการณ์โมดูลแอปพลิเคชันที่ได้รับการจัดการจะถูกประมวลผลเมื่อมีการเปิดใช้งาน Managed Application Thin และ Thick Client และ Web Client
โมดูล การสมัครปกติทำงานเมื่อเรียกใช้ Thick Client ในโหมด การสมัครปกติซึ่งมีอินเทอร์เฟซคำสั่งปกติในรูปแบบ เมนูหลัก.
หากแอปพลิเคชันกำลังทำงานอยู่ จัดการและในโหมด การสมัครปกติจึงจำเป็นต้องอธิบายขั้นตอนของตัวจัดการสำหรับโมดูล แอปพลิเคชันที่ได้รับการจัดการและสำหรับโมดูล การสมัครปกติ.
โมดูล แอปพลิเคชันที่ได้รับการจัดการสามารถเลือกได้จากเมนูบริบทของโหนดการกำหนดค่ารูท
โมดูลนี้ยังสามารถเปิดได้จากแผงคุณสมบัติขององค์ประกอบการกำหนดค่ารูท
เพื่อเปิดโมดูล การสมัครปกติคุณควรอ้างอิงถึงการตั้งค่าการกำหนดค่า (command ตัวเลือกในเมนู บริการ).
แบบฟอร์มจะเปิดขึ้น ตัวเลือก- บนบุ๊กมาร์ก ทั่วไปต้องระบุโหมดการแก้ไขการกำหนดค่า แอปพลิเคชันที่ได้รับการจัดการและ การสมัครปกติ.
ในกรณีนี้โมดูล การสมัครปกตินอกจากนี้ยังสามารถเปิดจากคุณสมบัติของโหนดรูทได้อีกด้วย
รายการเหตุการณ์ที่สามารถประมวลผลได้ จัดการและ การสมัครปกติก็เหมือนกัน
โมดูลนี้สามารถมีส่วนการประกาศตัวแปร ส่วนคำอธิบายของขั้นตอนและฟังก์ชันที่กำหนดเอง และส่วนโปรแกรมหลัก แต่นอกเหนือจากขั้นตอนและฟังก์ชันที่กำหนดเองแล้ว ตัวจัดการเหตุการณ์พิเศษยังสามารถอยู่ในโมดูลได้
รายชื่อตัวจัดการที่มีอยู่สามารถดูได้โดยการเรียกรายการขั้นตอนและฟังก์ชันของโมดูลปัจจุบันเมื่อโมดูลเปิดอยู่
หน้าต่างขั้นตอนและฟังก์ชันที่เปิดขึ้นจะแสดงขั้นตอนและฟังก์ชันทั้งหมดของโมดูลนี้ รวมถึงเหตุการณ์ที่ยังไม่ได้สร้างตัวจัดการ
มีสองเหตุการณ์ที่เกี่ยวข้องกับการเริ่มต้นระบบ (“ก่อน” และ “ที่”) สองเหตุการณ์ที่เกี่ยวข้องกับการปิดระบบ (“ก่อน” และ “ที่”) และยังประมวลผลเหตุการณ์ภายนอก (เช่น เหตุการณ์ของอุปกรณ์เชิงพาณิชย์)
เมื่อมีการดำเนินการตัวจัดการเหตุการณ์ "ก่อน" จะถือว่าการกระทำนั้นยังไม่เกิดขึ้น เมื่อมีการดำเนินการตัวจัดการเหตุการณ์ “at” แสดงว่าการดำเนินการเสร็จสิ้นแล้ว
เหตุการณ์ ก่อนเริ่มระบบเกิดขึ้นในขณะที่เปิดตัว Enterprise 8.3 แต่ตัวแอปพลิเคชันเองยังไม่ปรากฏบนหน้าจอ เหตุการณ์นี้มีพารามิเตอร์ต่อไปนี้: การปฏิเสธ.
หากพารามิเตอร์นี้รับค่า จริงจากนั้นแอปพลิเคชันจะไม่เริ่มทำงาน เหตุการณ์ เมื่อเริ่มต้นระบบถือว่าการดำเนินการเสร็จสิ้นแล้ว หน้าต่างได้ถูกสร้างขึ้นแล้ว และในกรณีนี้ เราสามารถแสดงแบบฟอร์มพิเศษบางอย่างได้ ไม่สามารถปฏิเสธการเปิดตัวได้อีกต่อไป
ในทำนองเดียวกัน ก่อนที่จะปิดระบบ แอปพลิเคชันยังคงเปิดอยู่และคุณสามารถปฏิเสธที่จะปิดได้ เมื่อระบบปิดลง หน้าต่างแอปพลิเคชันจะปิดไปแล้ว ทำได้เฉพาะการดำเนินการเพิ่มเติมเท่านั้น เช่น การลบไฟล์บางไฟล์หรือส่งอีเมล
ในโมดูล แอปพลิเคชันที่ได้รับการจัดการไม่ได้ระบุคำสั่งสำหรับขั้นตอนการคอมไพล์และฟังก์ชัน เนื่องจากโมดูลถูกคอมไพล์ทั้งหมดทางฝั่งไคลเอ็นต์ ซึ่งหมายความว่าในขั้นตอนและฟังก์ชันของโมดูล เราจะไม่สามารถเข้าถึงโดยตรง เช่น หนังสืออ้างอิง
ถ้ามาจากโมดูล แอปพลิเคชันที่ได้รับการจัดการจำเป็นต้องทำการเรียกเซิร์ฟเวอร์ จากนั้นคุณจะต้องสร้างสิ่งพิเศษ ด้วยธง .
ในโมดูล การสมัครปกติไม่มีข้อจำกัดดังกล่าว เนื่องจากโมดูลนี้จะถูกคอมไพล์เมื่อโหลด Thick Client ข้อมูลเกือบทุกประเภทมีอยู่ใน Thick Client
ขั้นตอน ฟังก์ชัน และตัวแปรของโมดูลแอปพลิเคชันสามารถอธิบายได้ว่าเป็นการส่งออก
เนื่องจากโมดูลถูกคอมไพล์ทั้งหมดบนไคลเอนต์ ซึ่งหมายความว่าในโพรซีเดอร์ไคลเอนต์ เราสามารถเข้าถึงเมธอดนี้และคุณสมบัตินี้ได้
ตัวอย่างเช่น คุณสามารถเรียกขั้นตอนหรือฟังก์ชันของโมดูลแอปพลิเคชันจากโมดูลแบบฟอร์มของออบเจ็กต์ได้ อย่างไรก็ตาม ขอแนะนำให้ใช้โมดูลทั่วไปเพื่ออธิบายอัลกอริทึมทั่วไป วัตถุประสงค์หลักของโมดูลแอปพลิเคชันคือเพื่อประมวลผลจุดเริ่มต้นและจุดสิ้นสุด
โดยการเปรียบเทียบกับโมดูลแอปพลิเคชัน โมดูลนี้ได้รับการออกแบบมาเพื่อประมวลผลเหตุการณ์การเปิดโปรแกรมและเหตุการณ์การปิดระบบ
แตกต่างจากโมดูลแอปพลิเคชันซึ่งเริ่มต้นในขณะที่เปิดใช้งานแอปพลิเคชันแบบโต้ตอบ โมดูลการเชื่อมต่อภายนอกจะทำงานในโหมดการเชื่อมต่อ COM เช่น เมื่อวัตถุ 1C:Enterprise 8 ถูกสร้างและเชื่อมต่อกับฐานข้อมูลเฉพาะ
โมดูลนี้มีเหตุการณ์: เมื่อเริ่มต้นระบบและ เมื่อปิดระบบ.
โมดูลการเชื่อมต่อภายนอกสามารถเปิดได้โดยใช้เมนูบริบทที่ระดับออบเจ็กต์การกำหนดค่ารูท หรือแผงคุณสมบัติสำหรับโหนดรูท
กระบวนการเชื่อมต่อภายนอกนั้นเป็นกระบวนการทำงานทางโปรแกรมกับฐานข้อมูลและไม่มีการโต้ตอบ ดังนั้น ในขณะนี้ คุณไม่สามารถใช้แบบฟอร์มโต้ตอบหรือแสดงข้อความเตือนได้ เนื่องจากไม่มีอินเทอร์เฟซผู้ใช้
ในโมดูลการเชื่อมต่อภายนอก คุณสามารถอธิบายตัวแปรการส่งออกและวิธีการส่งออกที่จะพร้อมใช้งานในด้านที่มีการเรียกภายนอกไปยัง 1C:Enterprise 8.3
เนื่องจากไม่มีอินเทอร์เฟซผู้ใช้ในการรวมภายนอก โมดูลการรวมภายนอกจึงถูกคอมไพล์ทั้งหมดบนเซิร์ฟเวอร์
โมดูลเซสชัน
โมดูลนี้จำเป็นสำหรับการเริ่มต้นพารามิเตอร์เซสชัน พารามิเตอร์เซสชันเป็นตัวแปรส่วนกลางด่วนซึ่งมีค่าอยู่ที่ใดก็ได้ในการกำหนดค่า
คุณสามารถเปิดโมดูลเซสชันผ่านเมนูบริบทหรือผ่านแผงคุณสมบัติของโหนดรูท
โมดูลเซสชันจัดให้มีกิจกรรม การตั้งค่าเซสชันพารามิเตอร์.
เมื่อแอปพลิเคชันเริ่มต้น กระบวนการนี้จะถูกเรียกก่อน พารามิเตอร์เซสชันจำเป็นสำหรับการทำงานของแอปพลิเคชันใดๆ ทั้งเมื่อเปิดใช้งานแบบโต้ตอบและเมื่อเปิดใช้งานในโหมดการเชื่อมต่อภายนอก
โมดูลเซสชันอธิบายการดำเนินการต่างๆ เพื่อเริ่มต้นพารามิเตอร์เซสชันโดยขึ้นอยู่กับเงื่อนไขที่แตกต่างกัน
ตามกฎแล้วโมดูลนี้จะอธิบายขั้นตอนต่างๆ ที่ถูกเรียกจากขั้นตอน การตั้งค่าเซสชันพารามิเตอร์- ดังนั้นขั้นตอนทั้งหมดเหล่านี้จึงถูกแยกออกเป็นโมดูลแยกต่างหาก
โมดูลเซสชันจะทำงานในโหมดสิทธิพิเศษเสมอ ซึ่งหมายความว่าจะไม่มีการตรวจสอบสิทธิ์เมื่อเข้าถึงฐานข้อมูล โมดูลเซสชันถูกคอมไพล์บนเซิร์ฟเวอร์ เช่น สามารถเข้าถึงวิธีการเซิร์ฟเวอร์ใด ๆ (รวมถึงการอ่านค่าจากฐานข้อมูล)
ในโมดูลเซสชัน คุณสามารถกำหนดเฉพาะขั้นตอนและฟังก์ชันได้ เช่น ไม่มีส่วนคำอธิบายตัวแปร และไม่มีส่วนโปรแกรมหลัก ไม่สามารถกำหนดวิธีการส่งออกในโมดูลเซสชันได้
หากเมื่อเริ่มต้นระบบ จำเป็นต้องดำเนินการบางอย่างบนเซิร์ฟเวอร์ เช่น สร้างองค์ประกอบของไดเร็กทอรี จากนั้นจึงสามารถใช้ Session Module เป็นตัวเลือกได้เนื่องจาก มันถูกคอมไพล์บนเซิร์ฟเวอร์และดำเนินการอย่างน่าเชื่อถือเสมอเมื่อเริ่มต้นระบบ อย่างไรก็ตาม จะต้องคำนึงถึงประเด็นต่อไปนี้:
- ขั้นตอน การตั้งค่าเซสชันพารามิเตอร์ไม่เพียงแต่เมื่อเริ่มต้นระบบเท่านั้น แต่ยังรวมถึงเมื่อเข้าถึงพารามิเตอร์เซสชันที่ไม่ได้กำหนดค่าเริ่มต้นด้วย เหล่านั้น. สามารถเรียกตัวจัดการ SetSessionParameters ซ้ำๆ ในระหว่างการทำงานของแอปพลิเคชัน
- หากจำนวนองค์ประกอบในอาร์เรย์พารามิเตอร์เซสชันเป็นศูนย์ (อาร์เรย์ของพารามิเตอร์ที่ต้องการมีประเภทข้อมูลเป็น ไม่ได้กำหนด) แสดงว่านี่คือช่วงเวลาที่แอปพลิเคชันเปิดตัว
- เนื่องจากโมดูลเซสชันทำงานในโหมดสิทธิพิเศษและจะไม่มีการตรวจสอบสิทธิ์การเข้าถึงคุณควรทำงานอย่างระมัดระวังกับวัตถุฐานข้อมูลเนื่องจากผู้ใช้สามารถเข้าถึงข้อมูลที่ไม่ควรมอบให้เขา
- เมื่อระบบเริ่มทำงานยังไม่ทราบแน่ชัดว่าแอปพลิเคชันจะเปิดตัวหรือไม่ ในกรณีนี้ การดำเนินการที่ไม่จำเป็นอาจถูกดำเนินการในตัวจัดการเหตุการณ์ SetSessionParameters
โมดูลเหล่านี้แสดงคำอธิบายของอัลกอริธึมทั่วไปบางอย่าง เช่น ขั้นตอนและฟังก์ชั่นที่สามารถเรียกได้จากที่ต่างๆ
วิธีการที่เกี่ยวข้องกันทางตรรกะสามารถจัดกลุ่มเป็นโมดูลทั่วไปที่แตกต่างกันได้ โมดูลเหล่านี้ถูกสร้างขึ้นภายในสาขาทั่วไป
คุณสามารถเพิ่มโมดูลที่ใช้ร่วมกันจำนวนเท่าใดก็ได้ หากต้องการให้วิธี Common Module พร้อมใช้งานในส่วนอื่นของการกำหนดค่า จะต้องกำหนดไว้ด้วยคำสำคัญ Export ขั้นตอนไคลเอนต์ของโมดูลทั่วไปจะพร้อมใช้งานบนไคลเอนต์ และขั้นตอนเซิร์ฟเวอร์ - บนเซิร์ฟเวอร์
ในโมดูลทั่วไป มีเพียงส่วนที่อธิบายขั้นตอนและฟังก์ชันเท่านั้นที่พร้อมใช้งาน เหล่านั้น. ใน General Module คุณไม่สามารถอธิบายตัวแปรได้ และคุณไม่สามารถอธิบายส่วนของโปรแกรมหลักได้
หากจำเป็นต้องใช้ตัวแปรร่วม คุณสามารถใช้พารามิเตอร์เซสชันหรือตัวแปรส่งออกโมดูลแอปพลิเคชันก็ได้
สำหรับโมดูลทั่วไป คุณสามารถตั้งค่าพารามิเตอร์บางตัวที่จะส่งผลต่อการทำงานของโมดูลนี้ได้ หากคุณสมบัติส่วนกลางถูกตั้งค่าสำหรับโมดูลทั่วไป วิธีการส่งออกที่ประกาศในโมดูลนี้จะสามารถเข้าถึงได้จากภายนอกโดยตรง โดยไม่มีคำแนะนำเพิ่มเติม
เหล่านั้น. ที่ให้ไว้ โมดูลทั่วไปจะมีส่วนร่วมในการก่อตัวของบริบทการกำหนดค่าทั่วโลก
คุณสมบัติ ทั่วโลกสำหรับโมดูลทั่วไปอาจมีประโยชน์ อย่างไรก็ตาม คุณไม่ควรใช้ทุกที่สำหรับโมดูลทั่วไปทั้งหมด
เหล่านั้น ซึ่งมีเครื่องหมายกำกับไว้ ทั่วโลกจะถูกคอมไพล์เมื่อเริ่มต้นระบบ ยิ่งโมดูลดังกล่าวมากเท่าไร โปรแกรมก็จะยิ่งเริ่มทำงานช้าลงเท่านั้น
ถ้าธง ทั่วโลกสำหรับ โมดูลทั่วไปไม่ได้ระบุ ดังนั้นการคอมไพล์โมดูลนี้จะดำเนินการในเวลาที่มีการเรียกครั้งแรก (เช่น หลังจากที่ระบบเริ่มทำงาน)
นอกจากนี้ การใช้โมดูลทั่วไปทั่วโลกยังส่งผลต่อความเข้าใจในโค้ดด้วย วิธีการของโมดูลทั่วไปที่ไม่ใช่สากลถูกเรียกผ่านชื่อ โมดูลทั่วไปและชื่อวิธีการ เช่น
โมดูลการคำนวณต้นทุน DistributeIndirectCosts();
ในกรณีนี้ ชื่อของโมดูลทั่วไปจะต้องสะท้อนถึงเนื้อหาของขั้นตอนที่อธิบายไว้ในนั้น การระบุชื่อของ Common Module เมื่อเรียกใช้โพรซีเดอร์ช่วยให้เข้าใจโค้ดได้ดียิ่งขึ้น
สำหรับ โมดูลทั่วไปวี จานสีคุณสมบัติคุณสามารถตั้งค่าคุณสมบัติได้ สิทธิพิเศษ.
โมดูลสิทธิพิเศษไม่ได้ควบคุมสิทธิ์การเข้าถึง นี่เป็นสิ่งจำเป็นถ้า โมดูลทั่วไปจำเป็นต้องดำเนินการประมวลผลข้อมูลจำนวนมากโดยรับข้อมูลจากฐานข้อมูล
การควบคุมสิทธิ์การเข้าถึงจะเพิ่มเวลาที่ใช้ในการเข้าถึงฐานข้อมูล และอัลกอริธึมจำนวนมากมักจะต้องทำงานโดยเร็วที่สุด
ตัวอย่างเช่น บัญชีเงินเดือนเป็นการดำเนินการที่ต้องใช้ทรัพยากรมาก จะต้องดำเนินการให้เร็วที่สุด ในการทำเช่นนี้ อัลกอริธึมที่คำนวณค่าจ้างจะถูกจัดอยู่ในสิทธิพิเศษ .
ในขณะเดียวกัน ขั้นตอนทั้งหมดที่รับรองว่าเอกสารเงินเดือนจะเสร็จสมบูรณ์อยู่นอกเหนือขั้นตอนเหล่านี้ โมดูลทั่วไป- ในขั้นตอนเหล่านี้จะมีการดำเนินการควบคุมสิทธิ์การเข้าถึง
ด้วยวิธีนี้ จึงสามารถบรรลุการปรับปรุงประสิทธิภาพที่สำคัญได้ โดยเฉพาะอย่างยิ่งเมื่อใช้กลไกสำหรับการควบคุมการเข้าถึงเรกคอร์ดตารางแบบแถวต่อแถว
หาก Common Module มีสิทธิ์ ขั้นตอนของโมดูลนี้สามารถคอมไพล์ได้บนเซิร์ฟเวอร์เท่านั้น
มีสถานการณ์ที่ผู้ใช้ไม่ควรเข้าถึงออบเจ็กต์บางอย่างได้ เช่น ไดเร็กทอรีบางตัว แต่เมื่อดำเนินการเอกสารฉบับใดฉบับหนึ่งจำเป็นต้องมีการอ้างอิงถึงหนังสืออ้างอิงนี้
เหล่านั้น. มีความจำเป็นต้องขยายสิทธิ์ผู้ใช้ชั่วคราวแล้วจึงคืนสิทธิ์ให้กลับสู่สถานะเดิม สามารถรับเอฟเฟกต์นี้ได้โดยใช้สิทธิพิเศษ โมดูลทั่วไป.
การทำเช่นนี้ในสิทธิพิเศษ โมดูลทั่วไปคุณควรสร้างขั้นตอนการเข้าถึงข้อมูลที่จำเป็น
ขั้นตอนนี้จะถูกเรียกจากเอกสารที่เกี่ยวข้อง เหล่านั้น. ผู้ใช้จะได้รับสิทธิ์เพิ่มเติมในเวลาที่เรียกใช้ขั้นตอนนี้
สำหรับ โมดูลทั่วไปสามารถระบุตำแหน่งการรวบรวมได้ ค่าสถานะใช้เพื่อกำหนดว่าโมดูลทั่วไปจะพร้อมใช้งานบนไคลเอ็นต์ (แอปพลิเคชันที่ได้รับการจัดการ) บนเซิร์ฟเวอร์ หรือในโหมดการเชื่อมต่อภายนอก
นอกจากนี้ หากคุณสลับโหมดการแก้ไขการกำหนดค่าเป็นแอปพลิเคชันที่ได้รับการจัดการและแอปพลิเคชันทั่วไป บริบทการคอมไพล์อื่นจะเป็นไปได้ - ไคลเอนต์ (แอปพลิเคชันปกติ)
ดังนั้นจึงมีสี่ตัวเลือกสำหรับการทำงานของโปรแกรม ขึ้นอยู่กับแอปพลิเคชันที่ทำงานอยู่ ขึ้นอยู่กับงานบนไคลเอนต์หรือบนเซิร์ฟเวอร์ โมดูลทั่วไปบางโมดูลจะพร้อมใช้งานหรือไม่พร้อมใช้งาน
นอกเหนือจากความสามารถในการระบุแฟล็กการคอมไพล์แล้ว ยังสามารถระบุคำสั่งการคอมไพล์สำหรับขั้นตอนและฟังก์ชันที่อยู่ใน Common Module ได้ด้วย
หากมีการระบุคำสั่งการคอมไพล์สำหรับวิธีการ แม้ว่าโมดูลทั่วไปจะพร้อมใช้งานในบริบทที่ระบุทั้งหมด ความพร้อมใช้งานของวิธีการเฉพาะจะถูกจำกัดโดยคำสั่งการคอมไพล์
ในกรณีนี้ ไม่สามารถเข้าถึงขั้นตอนในบริบทที่ไม่สามารถเข้าถึงได้โดยทั้งโมดูล
หากคุณไม่ได้ระบุคำสั่งการคอมไพล์สำหรับโพรซีเดอร์ (ฟังก์ชัน) มันจะถูกคอมไพล์ในบริบททั้งหมดที่กำหนดไว้สำหรับโมดูล
เหล่านั้น. โดยพื้นฐานแล้ว จะมีการจัดทำสำเนาขั้นตอนหลายชุด ทางเลือกของอินสแตนซ์ที่คอมไพล์แล้วขึ้นอยู่กับตำแหน่งที่เรียกใช้โพรซีเดอร์ (ตามกฎการโทรที่ใกล้เคียงที่สุด) ควรคำนึงว่าต้องเขียนรหัสของขั้นตอนดังกล่าวโดยคำนึงถึงความพร้อมใช้งานในบริบททั้งหมดที่กำหนดไว้สำหรับโมดูล
โมดูลทั่วไปที่สามารถเข้าถึงได้พร้อมกันในหลายบริบทได้รับการออกแบบมาเพื่อสร้างขั้นตอนที่สามารถเข้าถึงได้ในหลายบริบทเป็นหลัก
เมื่อสร้างโมดูลทั่วไป ถือเป็นแนวปฏิบัติที่ดีที่จะไม่ระบุคำสั่งการคอมไพล์ เหล่านั้น. ความพร้อมใช้งานของขั้นตอนและฟังก์ชันควรพิจารณาจากคุณสมบัติของโมดูลเอง
ด้วยแนวทางนี้ ขั้นตอนของไคลเอ็นต์จะอยู่ในโมดูลทั่วไปที่แยกจากกัน และขั้นตอนของเซิร์ฟเวอร์จะอยู่ในโมดูลทั่วไปที่แยกจากกัน
โมดูลที่มีการตั้งค่าสถานะการคอมไพล์หลายชุดนั้นไม่ค่อยมีการใช้งานมากนักในทางปฏิบัติ นี่คือการดำเนินการทั่วไปบางอย่างที่มีให้ทั้งบนไคลเอนต์และเซิร์ฟเวอร์ โดยปกติแล้วสิ่งเหล่านี้จะเป็นการคำนวณง่ายๆ
สำคัญ! เป็นไปได้ที่ไคลเอนต์จะเข้าถึงวิธีการส่งออกเซิร์ฟเวอร์ของโมดูลทั่วไป แต่เฉพาะในกรณีที่โมดูลทั่วไปนี้ถูกคอมไพล์บนเซิร์ฟเวอร์เท่านั้น ในกรณีนี้ มีการจัดเตรียมแฟล็กพิเศษเพื่อให้เข้าถึงได้จากไคลเอนต์ .
สำหรับโมดูลทั่วไปที่ไม่ใช่แบบสากล คุณสามารถแคชค่าที่ส่งคืนโดยฟังก์ชันได้ เหล่านั้น. หลังจากการเรียกใช้ฟังก์ชันครั้งแรก ระบบสามารถจดจำผลลัพธ์ของการดำเนินการได้ ถ้าฟังก์ชันนี้ถูกเรียกอีกครั้งด้วยพารามิเตอร์เดียวกัน ระบบจะส่งคืนค่าจากแคช
วัตถุประสงค์ของกลไกนี้คือเพื่อเพิ่มความเร็วในการโทรซ้ำ คุณต้องกำหนดค่าลักษณะการทำงานนี้ จานสีคุณสมบัติโมดูลตั้งค่าที่เหมาะสมสำหรับคุณสมบัติการใช้ซ้ำของค่าที่ส่งคืน
ตามค่าเริ่มต้น คุณสมบัตินี้จะถูกตั้งค่าเป็น ห้ามใช้ ค่าที่เป็นไปได้อื่นๆ: แคช ระหว่างการโทร, หรือ ตลอดระยะเวลาการประชุม.
คุณสมบัตินี้เหมาะสมที่จะใช้เฉพาะกับฟังก์ชันที่ผลลัพธ์ขึ้นอยู่กับพารามิเตอร์อินพุตเท่านั้น กลไกนี้ใช้ได้เฉพาะกับโมดูลทั่วไปที่ไม่ใช่แบบสากลเท่านั้น
หากเลือกค่าของพารามิเตอร์ที่สอดคล้องกันสำหรับระยะเวลาการโทร แคชจะทำงานตราบใดที่ขั้นตอนที่เรียกใช้เมธอด General Module ทำงานอยู่ หากเลือกค่าสำหรับระยะเวลาของเซสชัน ระบบจะถือว่าแคชทำงานในขณะที่ผู้ใช้ทำงานโดยมีเงื่อนไข
อย่างไรก็ตาม มีข้อจำกัดด้านเวลาบางประการ แคชจะถูกล้างโดยอัตโนมัติ 20 นาทีหลังจากที่ค่าเข้าสู่แคช
โมดูลแบบฟอร์ม
โมดูลนี้ออกแบบมาเพื่อประมวลผลการกระทำของผู้ใช้ ตัวอย่างเช่น อธิบายอัลกอริทึมว่าโปรแกรมตอบสนองอย่างไรเมื่อกดปุ่ม หรือตัวอย่างเช่น ในขณะที่ป้อนค่าในช่อง ให้ตรวจสอบความถูกต้องทันที
นอกจากเหตุการณ์ที่เกี่ยวข้องกับการควบคุมแบบฟอร์ม (ปุ่ม ช่องป้อนข้อมูล) แล้ว ยังมีเหตุการณ์ที่เกี่ยวข้องโดยตรงกับแบบฟอร์มอีกด้วย
ตัวอย่างเช่น คุณสามารถจัดการเหตุการณ์การเปิดของแบบฟอร์มและดำเนินการเริ่มต้นบางอย่างได้ คุณยังสามารถจัดการเหตุการณ์การปิดแบบฟอร์มและตรวจสอบว่าผู้ใช้ป้อนข้อมูลทุกอย่างถูกต้องหรือไม่
มีแบบควบคุมและแบบปกติ โมดูลของแบบฟอร์มเหล่านี้แตกต่างกันโดยหลักแล้วคือโมดูลฟอร์มที่ได้รับการจัดการจะถูกแบ่งออกเป็นบริบทอย่างชัดเจน แต่ละขั้นตอน (ฟังก์ชัน) ต้องมีคำสั่งการคอมไพล์ ในรูปแบบปกติ รหัสทั้งหมดจะถูกนำมาใช้กับไคลเอนต์
ในโมดูลฟอร์มที่มีการจัดการ คุณสามารถประกาศขั้นตอนและฟังก์ชัน คุณสามารถประกาศตัวแปร และคุณสามารถอธิบายส่วนของโปรแกรมหลักได้
รหัสโปรแกรมของโปรแกรมหลักจะถูกดำเนินการในเวลาเริ่มต้นของแบบฟอร์ม เช่น เมื่อผู้ใช้เริ่มเปิดมัน รูปภาพแสดงรายการเหตุการณ์มาตรฐานสำหรับแบบฟอร์มที่ได้รับการจัดการ
รายการเหตุการณ์ของแบบฟอร์มที่ได้รับการจัดการยังมองเห็นได้ในรายการคุณสมบัติโดยตรงสำหรับแบบฟอร์มนั้นด้วย รายการนี้ถูกเรียกในตัวแก้ไขแบบฟอร์มที่ได้รับการจัดการ
ในแบบฟอร์มที่มีการจัดการ คุณสามารถจัดการเหตุการณ์การเขียนของรายการได้ เหตุการณ์นี้จะปรากฏเฉพาะในรูปแบบออบเจ็กต์ (ไดเร็กทอรี เอกสาร และอื่นๆ) หากแบบฟอร์มไม่ได้ผูกไว้กับวัตถุใดวัตถุหนึ่ง จะไม่มีเหตุการณ์การเขียน
สำหรับโมดูลที่มีรูปแบบปกติ รายการเหตุการณ์มาตรฐานจะค่อนข้างเล็ก เนื่องจาก ในรูปแบบที่ได้รับการจัดการ เหตุการณ์จำนวนมากถูกสร้างขึ้นเพื่อจับคู่ (เหตุการณ์หนึ่งดำเนินการบนไคลเอนต์และอีกเหตุการณ์หนึ่งบนเซิร์ฟเวอร์) ในรูปแบบปกติ โค้ดทั้งหมดจะถูกดำเนินการบนไคลเอนต์
โมดูลวัตถุ
โมดูลเหล่านี้เป็นเรื่องปกติสำหรับไดเร็กทอรี เอกสาร แผนสำหรับประเภทการคำนวณ แผนผังบัญชี และวัตถุอื่นๆ อีกมากมาย โมดูลอ็อบเจ็กต์ได้รับการออกแบบมาเพื่อจัดการกับเหตุการณ์มาตรฐาน ตัวอย่างเช่น กิจกรรมสำหรับการป้อนองค์ประกอบไดเร็กทอรี, กิจกรรมสำหรับการเขียนองค์ประกอบ, การลบ, การโพสต์เอกสาร ฯลฯ
โดยหลักการแล้ว เหตุการณ์การเขียนยังมีอยู่ใน Form Module อีกด้วย แต่เหตุการณ์การเขียนใน Form Module เกิดขึ้นระหว่างกระบวนการบันทึกแบบโต้ตอบ เมื่อทำงานกับแบบฟอร์มเฉพาะ
เหตุการณ์การเขียนใน Object Module จะถูกดำเนินการกับการเขียนใดๆ จากรูปแบบใดๆ ของวัตถุที่กำหนด นอกจากนี้ ถ้าวัตถุถูกเขียนโดยทางโปรแกรม เหตุการณ์โมดูลของวัตถุจะเริ่มทำงาน
ในเหตุการณ์การเขียนของ Object Module คุณสามารถสร้างการตรวจสอบความถูกต้องของข้อมูลที่กำลังเขียนทั้งหมดได้ เนื่องจากขั้นตอนนี้จะดำเนินการในเวลาที่มีการบันทึกใดๆ ก็ตาม
โมดูลของออบเจ็กต์นี้สามารถเรียกผ่านเมนูบริบท จาก Object Properties Palette และจากหน้าต่างการแก้ไขออบเจ็กต์
รูปด้านล่างแสดงรายการเหตุการณ์โมดูลไดเร็กทอรีที่มีอยู่
ใน Object Module คุณสามารถวางส่วนสำหรับอธิบายตัวแปร อธิบายฟังก์ชันที่กำหนดเองที่อาจไม่เกี่ยวข้องกับเหตุการณ์ เช่นเดียวกับส่วนของโปรแกรมหลัก
ในส่วนโปรแกรมหลัก คุณสามารถกำหนดค่าเริ่มต้นให้กับตัวแปรภายในเครื่องของโมดูลที่กำหนดได้ เป็นต้น รหัสโปรแกรมนี้จะถูกดำเนินการเมื่อมีการเข้าถึงโมดูลออบเจ็กต์นี้
ควรสังเกตว่าขั้นตอนทั้งหมดของ Object Module ได้รับการคอมไพล์บนเซิร์ฟเวอร์ ดังนั้นจึงไม่จำเป็นต้องมีคำสั่งการคอมไพล์สำหรับขั้นตอนและฟังก์ชันของ Object Module ออบเจ็กต์การกำหนดค่าบางอย่างไม่มีโมดูลออบเจ็กต์
นี่เป็นเพราะลักษณะของวัตถุนั่นเอง วัตถุดังกล่าวได้แก่ ค่าคงที่และ ลงทะเบียน- สำหรับ คงที่ไม่มีโมดูลอ็อบเจ็กต์ แต่มีโมดูลที่คล้ายกันมากที่เรียกว่า โมดูลตัวจัดการมูลค่า.
ใน โมดูลตัวจัดการมูลค่าคุณสามารถจัดการเหตุการณ์การเขียนได้ ค่าคงที่และกรอกขั้นตอนการตรวจสอบ
บริบทของโมดูลทั้งหมดถูกดำเนินการบนเซิร์ฟเวอร์
สำหรับการลงทะเบียนจะมีโมดูลชุดระเบียน
โมดูลนี้ยังมีความสามารถในการจัดการเหตุการณ์การเขียนและดำเนินการตรวจสอบการเข้าใช้
ใน Object Modules, Value Manager Modules (สำหรับค่าคงที่) และ Recordset Modules (สำหรับรีจิสเตอร์) คุณสามารถอธิบายวิธีการที่สามารถส่งออกได้ และวิธีการเหล่านี้จะสามารถเข้าถึงได้จากภายนอก
เหล่านั้น. นอกเหนือจากการใช้เมธอดคงที่ของคลาสอ็อบเจ็กต์แล้ว คุณสามารถสร้างเมธอดเพิ่มเติมสำหรับอ็อบเจ็กต์ใน Object Module ได้ โมดูลนี้ควรอธิบายขั้นตอนที่เกี่ยวข้องกับคำสำคัญ ส่งออก.
จากนั้นจะสามารถเข้าถึงขั้นตอนนี้จากภายนอกได้ นอกจากนี้ วิธีการนี้จะแสดงในคำแนะนำเครื่องมือบริบท วิธีการใหม่ในคำแนะนำเครื่องมือบริบทจะถูกเน้นด้วยแบบอักษรสีน้ำเงิน (ไอคอนสีน้ำเงิน พี()สำหรับขั้นตอนและ ฉ()สำหรับฟังก์ชั่น)
ในทำนองเดียวกัน คุณสามารถสร้างคุณสมบัติใหม่ได้โดยการประกาศตัวแปรด้วยคีย์เวิร์ด ส่งออก- ที่พักแห่งนี้ยังสามารถเข้าถึงได้จากภายนอก
ด้วยวิธีนี้ เป็นไปได้ที่จะขยายการทำงานของออบเจ็กต์ (เพื่อกำหนดวิธีการใหม่และคุณสมบัติใหม่) อย่างไรก็ตาม คุณสมบัติเป็นแบบไดนามิกและไม่ได้บันทึกไว้ในฐานข้อมูล
หากคุณต้องการใช้คุณสมบัติสำหรับวัตถุที่จะถูกเก็บไว้ในฐานข้อมูล คุณควรสร้างแอตทริบิวต์ของวัตถุ
โมดูลผู้จัดการ
โมดูลนี้มีอยู่ในออบเจ็กต์จำนวนมาก (ไดเร็กทอรี เอกสาร รีจิสเตอร์ ฯลฯ) โมดูลถูกเปิดผ่านเมนูบริบทสำหรับออบเจ็กต์หรือผ่าน จานสีคุณสมบัติหรือผ่านหน้าต่างแก้ไข
ในโมดูลผู้จัดการ คุณสามารถแทนที่เหตุการณ์มาตรฐานบางอย่างได้ ตัวอย่างเช่น ใน กำลังประมวลผลข้อมูลการเลือกรับเมื่อเลือกองค์ประกอบจากไดเร็กทอรี ก็สามารถทำการกรองหรือตรวจสอบเพิ่มเติมได้
นอกจากนี้ คุณสามารถสร้างวิธีการเพิ่มเติมในโมดูลผู้จัดการและระบุว่าเป็นวิธีการส่งออกได้ ในกรณีนี้สามารถเข้าถึงวิธีการเหล่านี้จากภายนอกได้
เพื่อดำเนินการเรียกนี้ จำเป็นต้องได้รับชนิดข้อมูล DirectoryManager.
ความแตกต่างระหว่างวิธีการส่งออกของโมดูลผู้จัดการและโมดูลวัตถุก็คือ ในการเข้าถึงวิธีการของโมดูลวัตถุนั้น คุณต้องได้รับออบเจ็กต์นั้นก่อน (นั่นคือ รับลิงก์ด้วยวิธีใดวิธีหนึ่ง จากนั้นจึงแปลงลิงก์นี้เป็นออบเจ็กต์) .
หลังจากนี้ ตัวแปรการส่งออกและวิธีการของ Object Module จะพร้อมใช้งาน สำหรับโมดูลผู้จัดการ การเรียกจะง่ายกว่า ตัวอย่างเช่น:
ไดเรกทอรี คู่สัญญา วิธีการชื่อ
นี่เป็นข้ออุทธรณ์สองประการที่แตกต่างกัน แปลงจากการอ้างอิงเป็นวัตถุ (method รับวัตถุ) เป็นการกระทำที่ค่อนข้างจริงจังสำหรับระบบ เนื่องจากเมื่อได้รับวัตถุ ข้อมูลทั้งหมดของวัตถุนี้จะถูกอ่านอย่างแน่นอน ซึ่งอาจมีความยาวพอสมควร
ข้อแตกต่างประการที่สองก็คือ โมดูลวัตถุเรียกว่าในบริบทขององค์ประกอบเฉพาะ ดังนั้น เราสามารถสรุปได้ว่าใช้ได้กับองค์ประกอบที่กำหนด (ในกรณีส่วนใหญ่ นี่คือตรรกะที่ใช้อย่างแน่นอน)
สำหรับโมดูลผู้จัดการ จะอธิบายการดำเนินการทั่วไปบางอย่างสำหรับกลุ่มหรือองค์ประกอบทั้งหมดของไดเร็กทอรีหรือเอกสารบางส่วน ตัวอย่างเช่น หากคุณต้องการพิมพ์รายการไดเร็กทอรี คุณสามารถใช้ Object Module ได้
แต่ในโมดูลตัวจัดการ คุณสามารถสร้างกลไกที่เป็นสากลมากขึ้นซึ่งจะพิมพ์กลุ่มขององค์ประกอบ เหนือสิ่งอื่นใด
นอกจากนี้ การเข้าถึงโมดูลอ็อบเจ็กต์ยังคงเป็นการดำเนินการที่ยาวนานกว่า ดังนั้นจึงควรแก้ไขปัญหานี้ในโมดูลตัวจัดการมากกว่า
นี่เป็นการสรุปความคุ้นเคยของเรากับโมดูลในการกำหนดค่าระบบ 1C:Enterprise หากเราสรุปทั้งหมดข้างต้นโดยย่อ บรรทัดล่างคือข้อสรุปดังต่อไปนี้:
- โมดูลซอฟต์แวร์เป็นส่วนหนึ่งของการกำหนดค่าที่สามารถมีได้เฉพาะข้อความในภาษา 1C ในตัวเท่านั้น
- โมดูลซอฟต์แวร์แบ่งตามประเภทที่เรากล่าวถึงในบทความนี้ แต่ละมุมมองจะถูกกำหนดโดยตำแหน่งและบริบทของโปรแกรมที่มีอยู่
- โครงสร้างของโมดูลประกอบด้วยหลายส่วนซึ่งจัดเรียงตามลำดับที่กำหนด องค์ประกอบของส่วนต่างๆ จะพิจารณาจากประเภทของโมดูล
โปรดทราบว่าเราจงใจละเว้นโมดูลประเภทหนึ่ง นั่นคือโมดูลคำสั่ง ไม่มีอะไรโดดเด่น และเราขอเชิญชวนให้คุณทำความคุ้นเคยกับฟังก์ชันการทำงานของมัน
จนถึงตอนนี้ เราได้พิจารณาโค้ดโปรแกรมทั้งหมดของเราแยกจากโซลูชันแอปพลิเคชัน และตามกฎแล้ว เราเขียนมันไว้ในการกำหนดค่าการทดสอบเล็กๆ น้อยๆ ของเราเอง คุณทราบหรือไม่ว่า “คุณไปไม่ได้แล้ว” และเริ่มแก้ไขโค้ดของการกำหนดค่ามาตรฐาน เลขที่? แล้วในบทความหน้าเราจะอธิบายทั้งหมด!
โอเค 693 22.12.13 22:44 ขณะนี้อยู่ในหัวข้อ
() เริ่มจากสิ่งสำคัญกันก่อน เรื่องไร้สาระและเรื่องไร้สาระเป็นความพยายามที่จะระบายสีการแสดงออกด้วยอารมณ์ ซึ่งค่อนข้างยากที่จะทำผ่านประเภทจดหมายเหตุ นี่เป็นการแสดงออกถึงความเข้าใจผิดของฉัน และไม่ใช่ความพยายามที่จะทำให้ขุ่นเคือง เป็นการดีที่จะจัดการกับคนที่เข้าใจเรื่องนี้ ถ้าฉันทำให้คุณขุ่นเคืองฉันขอโทษ
การเปรียบเทียบนั้นไม่เหมาะสม เนื่องจากลักษณะของ OOP OOP เป็นทายาทของการเขียนโปรแกรมแบบขั้นตอนและโมดูลาร์ เปรียบเสมือนการเปรียบเทียบพ่อกับลูก โดยยกลูกให้เป็นตัวอย่างแก่พ่อ
เป็นการยากที่จะโต้แย้งกับข้อความดังกล่าว แต่ความหมายของคำพูดนี้มีความเกี่ยวข้องเล็กน้อยกับข้อความที่แสดงความคิดเห็นในบทความ
สิ่งนี้เกี่ยวข้องกับตัวอย่างที่ให้ไว้ในบทความ วิธีการนี้มีคำสั่งในการรวบรวมและด้วยเหตุผลบางประการจึงละเว้นคำหลัก "ส่งออก"
การที่เขาไม่เคยต้องทำอะไรบางอย่างไม่ได้หมายความว่ามันไม่เกี่ยวข้องหรือคนอื่นไม่ได้ทำ
ใช่. ฉันไม่จำเป็นต้องเปลี่ยนโมดูลทั่วไปสำหรับการประมวลผลภายนอก จำเป็นต้องสร้างเวอร์ชันที่แตกต่างกันสำหรับการกำหนดค่าที่แตกต่างกัน
ในแอปพลิเคชันทั่วไป มักใช้เพื่อแก้ไขปัญหาอินเทอร์เฟซเพียงอย่างเดียว:
นั่นแหละ ตามปกติ ฉันไม่ได้ทำนายการตายของมัน (เป็นวิธีแก้ปัญหาที่ดีและได้รับการพิสูจน์แล้ว) แต่แนวโน้มเป็นเช่นนั้นที่ 1C กำลังก้าวไปสู่การประมวลผลแบบกระจายมากขึ้นเรื่อยๆ โดยมีการจัดสรรโค้ดอย่างชัดเจนตามสถานที่ที่มันทำงาน มันไม่ค่อยได้ผลที่นี่ (ถ้ามันได้ผลเลย): “ ทุกอย่างอยู่บนไคลเอนต์แล้วเราจะหาคำตอบเอง” หรือ “มาดึงเซิร์ฟเวอร์กันดีกว่า - หลังจากนั้น เรามีกิกะบิต”
ฉันคิดว่ามันจะมีประโยชน์ในการขยายสิ่งที่เป็นนามธรรมที่มีอยู่ในแนวคิดของ "GeneralModule" และนำไปใช้ในการกำหนดค่า
เอนทิตีประเภทใหม่ เช่น "ExecutableModule" ซึ่งคล้ายกับอ็อบเจ็กต์โมดูลจาก MS VBA
"GeneralModules" จะเป็นกรณีพิเศษของวัตถุ "ExecutableModule" ซึ่งอยู่โดยประมาณ
ในความสัมพันธ์เดียวกันกับวัตถุ "GeneralForm" และเพียงแค่ "Form"....
เริ่มต้นด้วยการใช้เนมสเปซและข้อมูลเมตาของโมดูลใน 1C คงจะดีไม่ใช่ตอนนี้ (คำพูดจากผู้ช่วยไวยากรณ์) "ไม่ได้กำหนด - เนื่องจากไม่คาดว่าจะทำงานจากภาษาในตัว"
สมมติว่าจำนวนสถานะที่ใช้ในแบบฟอร์มมีจำนวนมาก และสมมติว่าเป็นเช่นนั้น
เมื่อใช้แบบฟอร์มความน่าจะเป็นที่จะตระหนักถึงสถานะเฉพาะนั้นต่ำ
ในการเขียนโปรแกรมเว็บแบบคลาสสิก สิ่งนี้ได้รับการแก้ไขโดยความสามารถในการฝังแบบฟอร์มในรูปแบบและการเรียกแบบอะซิงโครนัส (AJAX) น่าเสียดายที่ 1C ละเลยสิ่งนี้ ดังนั้นจึงเหลือสามทางเลือก:
1. ใช้รูปแบบที่แตกต่างกัน
2. ถ่ายโอนข้อมูลที่จำเป็นทั้งหมดไปยังไคลเอนต์
3. ดึงเซิร์ฟเวอร์
โดยทั่วไปแล้ว การเรียกเซิร์ฟเวอร์นอกบริบทไม่ถือว่าเป็นสิ่งที่ไม่ดี และควรหลีกเลี่ยง
- โดยหลักการแล้ว ยังมีความคิดเห็น (ซึ่งฉันไม่เห็นด้วยอย่างยิ่ง) ว่าเป็นตัวเลข "พิเศษ" บางประเภท
การเรียกบริบทของเซิร์ฟเวอร์นั้นชั่วร้ายน้อยกว่าหากการปรับให้เหมาะสม "เกินไป" ทำให้ "ความสามารถในการอ่าน" ของโค้ดสับสน
การเรียกเซิร์ฟเวอร์นอกบริบทได้รับการออกแบบมาเพื่อลดการรับส่งข้อมูลเมื่อถ่ายโอนข้อมูลจากไคลเอนต์ไปยังเซิร์ฟเวอร์ นี่เป็นวิธีเดียวที่แตกต่างจากบริบท
ตัวอย่างที่ 1: คุณต้องได้รับคู่สัญญาตามเอกสาร
เซิร์ฟเวอร์ไคลเอนต์
1. แบบฟอร์มการคัดเลือก --> แบบฟอร์มการรับ
2. เมื่อมีการเปลี่ยนแปลง<--
3. รับคู่สัญญา -> DocumentBase["คู่สัญญา"]
ในขั้นตอนที่สาม การลากแบบฟอร์มทั้งหมดพร้อมรายละเอียดทั้งหมดไปยังเซิร์ฟเวอร์ไม่มีประโยชน์ ดังนั้นจึงแนะนำให้ใช้ OnServerWithoutContext
ในเวอร์ชันของคุณคุณสามารถใช้:
สำหรับวิธีการโมดูลวัตถุ:
&บนเซิร์ฟเวอร์โดยไม่มีบริบท
ฟังก์ชั่น Something_with_something (ProcessingObject, ProcessingTypeString, พารามิเตอร์)
ส่งกลับ FormDataValue (ProcessingObject, Type (ProcessingTypeString)). FunctionWe Need (พารามิเตอร์);
EndFunction
สำหรับวิธีการของโมดูลผู้จัดการ:
&บนเซิร์ฟเวอร์โดยไม่มีบริบท
ฟังก์ชั่น Something_with_something (ชื่อ, พารามิเตอร์)
การประมวลผลกลับ [ชื่อ] .FunctionWeNeed (พารามิเตอร์);
EndFunction
คำถาม: ฉันจะเรียกใช้ฟังก์ชันจากแบบฟอร์มที่ได้รับการจัดการที่อยู่ในโมดูลของวัตถุอื่นได้อย่างไร
จะเรียกใช้ฟังก์ชันจากแบบฟอร์มที่ได้รับการจัดการที่มีอยู่ในโมดูลของวัตถุอื่นได้อย่างไร
ฉันกำลังพยายาม:
&บนเซิร์ฟเวอร์
ขั้นตอน MyProcedure() การประมวลผล = แบบฟอร์ม AttributesValue ("บันทึก", ประเภท ("ProcessingObject.NecessaryProcessing"));
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้องคำตอบ:
และสิ่งนี้ไม่เพียงแต่ใช้กับการประมวลผลเท่านั้น แต่โดยหลักการแล้ว แม้กระทั่งกับวัตถุใดๆ ก็ตาม
คุณยังสามารถกรอกรายละเอียดและเรื่องไร้สาระอื่น ๆ ที่เกิดขึ้นจากการประมวลผลหนึ่งไปยังอีกการประมวลผลหนึ่งได้
สวัสดี!
โปรดให้ตัวอย่างโค้ดแก่ฉันเกี่ยวกับวิธีที่คุณสามารถเรียกแบบฟอร์มที่พิมพ์เสร็จแล้วโดยทางโปรแกรมโดยใช้ลิงก์ไปยังวัตถุ
ตัวอย่างเช่น,
...
link=Documents.InvoiceIssued.FindByCode(...);
ลิ้ง...รับข้อมูลแบบฟอร์มสำหรับพิมพ์...
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้องฯลฯ
เรียกคำสั่งที่เรียกใช้การพิมพ์เอกสารนี้และมีพารามิเตอร์เดียว - นี่คือเอกสารของคุณ
คำถาม: แบบฟอร์มที่ได้รับการจัดการใน UPP 1.3
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้องสวัสดีตอนบ่าย ในตัวกำหนดค่า ฉันสร้างการประมวลผลด้วยแบบฟอร์มที่ได้รับการจัดการ (เปลี่ยนแฟล็กเป็นได้รับการจัดการ) ในโหมดองค์กรจะไม่เปิดเลย ใครเจอบ้างคะ? จะเปิดแบบฟอร์มที่ได้รับการจัดการที่สร้างขึ้นได้อย่างไร?
<<К сожалению, это невозможно. Свойство "Использовать управляемые формы в обычном приложении" не влияет на внешние обработки и отчёты. В обычном приложении можно открывать только обычные формы таких объектов, а в управляемом только управляемые. Это ограничение платформы.>>
+() คลาสสิกของประเภท:
คำถาม: [แก้ไขแล้ว] การเรียกขั้นตอนโมดูลฟอร์มจากโมดูลฟอร์มที่ได้รับการจัดการที่ประมวลผลภายนอก
8.3.9.2170
เรียนผู้เชี่ยวชาญ โปรดบอกฉัน:
จะเรียกขั้นตอนของโมดูลแบบฟอร์มของเอกสารนี้จากขั้นตอนไคลเอนต์ของโมดูลแบบฟอร์มการประมวลผลภายนอก (EF) ที่ผูกไว้กับเอกสารได้อย่างไร
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้อง
ขอบคุณ
รับแบบฟอร์มเอกสารและเรียกใช้ฟังก์ชันการส่งออกที่ต้องการในโมดูลแบบฟอร์มผลลัพธ์
สวัสดี!
ในที่สุดฉันก็เริ่มทำงานกับแบบฟอร์มที่ได้รับการจัดการ รวมถึงแบบฟอร์มเพิ่มเติมด้วย รายละเอียดไดเร็กทอรีที่ป้อนในโหมดองค์กร
1C:องค์กร 8.3 (8.3.8.2054), 1C:ระบบอัตโนมัติแบบรวม 2 (2.2.3.196)
ขออภัย ฉันประสบปัญหาและไม่สามารถแก้ไขปัญหาของ Google ได้
สาระสำคัญคือสิ่งนี้ - มีการประมวลผลภายนอกโดยผู้ใช้เลือกรายการหลังจากนั้นควรกรอกฟิลด์อื่น ๆ ของการประมวลผลนี้ด้วยรายการเพิ่มเติมโดยอัตโนมัติ รายละเอียดของการตั้งชื่อนี้ ฉันสะดุดตั้งแต่แรก - ฉันกำลังพยายามรับสิ่งพิเศษเหล่านี้พร้อมกับคำขอ รายละเอียด.
| 1ซี | ||
|
||
ตั้งค่าพารามิเตอร์
("ระบบการตั้งชื่อ", วัตถุ ระบบการตั้งชื่อ) ;
ResultRequest สำหรับรายละเอียดเพิ่มเติม = ขอรายละเอียดเพิ่มเติม ดำเนินการ() ยกเลิกการโหลด() ;
ส่งคืน ResultRequestAdditionalDetails;
สิ้นสุดฟังก์ชัน
ส่งคืน ResultRequestAdditionalDetails;
ปัญหา
"(ExternalProcessing.PrintLabels.Form.Form.Form(11)): เกิดข้อผิดพลาดเมื่อเรียกวิธีบริบท (RequestAdditionalDetails)
ส่งคืน ResultRequestAdditionalDetails;
รายละเอียดเพิ่มเติม = ขอรายละเอียดเพิ่มเติม (Object.Nomenclature);
เนื่องจาก:
เกิดข้อผิดพลาดในการถ่ายโอนข้อมูลระหว่างไคลเอนต์และเซิร์ฟเวอร์ ค่านี้เป็นประเภทที่ไม่ถูกต้อง
ข้อผิดพลาดในการแปลงข้อมูล XDTO:
หน้าแรกคุณสมบัติ: ret แบบฟอร์ม: ประเภทองค์ประกอบ: (http://www.w3.org/2001/XMLSchema)anyType
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้องพิมพ์ข้อผิดพลาดในการแมป:
ไม่มีการแสดงผลสำหรับประเภท "(http://v8.1c.ru/8.1/data/core)ValueTable""
กรุณาช่วย!
เพิ่มหลังจาก 9 นาที
ฉันจะพยายามสร้างแท็บ ส่วนหนึ่งของการประมวลผล (โดยไม่ต้องวางลงในแบบฟอร์ม) และโหลดผลลัพธ์ลงไป
และมันก็เกิดขึ้น! ขอบคุณ!
คำถาม: การทำงานกับตารางค่าในรูปแบบที่ได้รับการจัดการ
ขอให้เป็นวันที่ดี ตารางค่านิยมไม่เคยหยุดทำให้ฉันประหลาดใจ นี่คือคำถามที่แท้จริง: ฉันกำลังสร้างการประมวลผลภายนอก (แบบฟอร์มควบคุม) ฉันกำลังสร้างแอตทริบิวต์ "TK" ด้วยประเภท "ตารางค่า" และฉันก็ลากมันลงบนแบบฟอร์ม ถัดไปในโมดูลแบบฟอร์ม ฉันเขียน "TZ" และหลังจุดในรายการแบบเลื่อนลง ฉันไม่เห็นคุณสมบัติ "คอลัมน์" ต่อไป ฉันสร้างโดยทางโปรแกรม:
และเขียน "TZ" ในรายการแบบเลื่อนลง มีคุณสมบัติ "คอลัมน์"- คำถามคือทำไม????????
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้อง
ข้อความจาก บริโอลิน
และจำเป็นต้องทำ 1C เพื่อที่จะเขียนโดยตรงในตัวปรับแต่งว่าแอตทริบิวต์ในแบบฟอร์มมีประเภทข้อมูลเป็น DataFormsCollection!
จากนั้นจะไม่ชัดเจนว่าสามารถแปลวัตถุแอปพลิเคชันใดได้
คำถาม: แบบฟอร์มที่ได้รับการจัดการ (การเข้าถึงองค์ประกอบ)
การใช้แพลตฟอร์ม UTeshki 10.3.40.1 8.3.9.2033 ฉันกำลังสร้างแบบฟอร์มการเลือกผลิตภัณฑ์บนเว็บ ฉันสร้างบทบาทใหม่และค่อยๆ เริ่มเปิดการเข้าถึงวัตถุต่างๆ ทุกอย่างเรียบร้อยดีจนกระทั่งฉันไปถึงไดเร็กทอรี Values of properties of object เป็นที่ชัดเจนว่าใน 10 ไม่มีรูปแบบการจัดการทั้งหมดถูกสร้างขึ้นในกระบวนการ แต่ถ้าแบบฟอร์มสำหรับการเลือก "คุณสมบัติของวัตถุ" เดียวกันถูกสร้างขึ้นตามปกติแล้วแบบฟอร์มสำหรับการเลือก "ค่าของคุณสมบัติวัตถุ" จะถูกสร้างขึ้น ด้วยองค์ประกอบที่ไม่ใช้งาน... และสิ่งที่ฉันยังไม่ได้ลอง - สิทธิ์ในการอ่านดูทั้งหนังสืออ้างอิงและแผนประเภทของลักษณะคุณสมบัติของวัตถุ... ไม่มีอะไรช่วย ขุดที่ไหน? ไม่จำเป็นต้องเสนอตัวเลือกในการสร้างแบบฟอร์มแยกต่างหากและจดทุกอย่างลงไป ฉันทิ้งไว้ในกรณีที่เหตุผลยังไม่ชัดเจน
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้องบางทีการเข้าถึงอาจถูกตั้งค่าในแบบฟอร์มตามเงื่อนไขบางประการ
คำถาม: เมื่อปิดแบบฟอร์มไดเร็กทอรีที่มีการจัดการ ฉันเขียนถึงทะเบียนข้อมูล
เมื่อปิดแบบฟอร์มไดเร็กทอรีที่มีการจัดการ ฉันจะเขียนไปยังทะเบียนข้อมูล
หากมีการสร้างรายการไดเร็กทอรีใหม่ ข้อผิดพลาดคือยังไม่ได้สร้างออบเจ็กต์ไดเร็กทอรี ฉันไม่เข้าใจว่าจะต้องรอให้สร้างออบเจ็กต์ไดเร็กทอรีอย่างไร
ท้ายที่สุดฉันเรียกมันว่าเมื่อปิดแบบฟอร์มไดเร็กทอรี?
&บนเซิร์ฟเวอร์
ขั้นตอนเมื่อ ClosingOnServer() Set=InformationRegisters.ContactInformation.CreateRecordSet();
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้อง() บางทีนี่อาจไม่จำเป็นในการนำไปปฏิบัติ () ฉันคิดว่าเขาแสดงออกไม่ถูกต้อง นี่หมายถึงข้อมูลที่แก้ไข คุณทำสิ่งที่คล้ายกันเมื่อเขาแนะนำความเป็นสากล โดยจัดเก็บสตริงรายละเอียดด้วยภาษาอังกฤษ/สเปน และชื่ออื่นๆ เพื่อไม่ให้อุปกรณ์ประกอบฉากสำหรับแต่ละภาษา ฉันจึงใส่ทุกอย่างไว้ในทะเบียน และการบันทึกก็ทำควบคู่ไปกับการบันทึกไดเร็กทอรีใด ๆ บางอย่างเช่นนี้
คำถาม: โครงสร้างขององค์ประกอบบนแบบฟอร์มที่ได้รับการจัดการ จะค้นหาองค์ประกอบที่ต้องการโดยไม่ต้องค้นหาผ่านองค์ประกอบได้อย่างไร?
คุณต้องค้นหาฟิลด์ตารางในแบบฟอร์มที่ได้รับการจัดการ ฉันทำสิ่งนี้โดยการวนซ้ำองค์ประกอบแบบฟอร์มทั้งหมด อาจมีวิธีอื่นในการค้นหาองค์ประกอบที่ต้องการของแบบฟอร์มที่ได้รับการจัดการหรือไม่
ตัวอย่างการค้นหาด้วยกำลังเดรัจฉาน:
//****** FlFoundTablePart = เท็จ;<>สำหรับแต่ละ El จาก _ThisForm.Elements Cycle ถ้า TypeValue(El)
พิมพ์("FormTable") จากนั้นดำเนินการต่อ;
สิ้นสุดถ้า;
ถ้า El.DataPath = "วัตถุ" + _TablePartName จากนั้น FlFoundTabularPart = True;
ยกเลิก;
สิ้นสุดถ้า;
สิ้นสุดรอบ; -
ผลลัพธ์ = Processing.ExportProcedureInNecessaryProcessingModule ("พารามิเตอร์ที่จำเป็น"); ข้อผิดพลาดจุดสิ้นสุดของขั้นตอน: พารามิเตอร์หมายเลข 1 ไม่ถูกต้องคำถาม: เขียน() ในรูปแบบที่ได้รับการจัดการ
สถานการณ์มีดังนี้:
