บทความนี้ยังคงดำเนินต่อไปในซีรีส์ "ขั้นตอนแรกในการพัฒนาบน 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 ในตัวเท่านั้น
• โมดูลซอฟต์แวร์แบ่งตามประเภทที่เรากล่าวถึงในบทความนี้ แต่ละมุมมองจะถูกกำหนดโดยตำแหน่งและบริบทของโปรแกรมที่มีอยู่
• โครงสร้างของโมดูลประกอบด้วยหลายส่วนซึ่งจัดเรียงตามลำดับที่กำหนด องค์ประกอบของส่วนต่างๆ จะพิจารณาจากประเภทของโมดูล

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

จนถึงตอนนี้ เราได้พิจารณาโค้ดโปรแกรมทั้งหมดของเราแยกจากโซลูชันแอปพลิเคชัน และตามกฎแล้ว เราเขียนมันไว้ในการกำหนดค่าการทดสอบเล็กๆ น้อยๆ ของเราเอง คุณทราบหรือไม่ว่า “คุณไปไม่ได้แล้ว” และเริ่มแก้ไขโค้ดของการกำหนดค่ามาตรฐาน เลขที่? แล้วในบทความหน้าเราจะอธิบายทั้งหมด!

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

1.2. เมื่อพัฒนาโมดูลที่ใช้ร่วมกัน คุณควรเลือกหนึ่งในสี่บริบทการเรียกใช้โค้ด:

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

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

• เซิร์ฟเวอร์(ช่องทำเครื่องหมาย โทรเซิร์ฟเวอร์รีเซ็ต)
• ลูกค้า (สมัครปกติ),
• เข้าร่วมด้านนอก.

ในกรณีนี้ รับประกันความสามารถในการเรียกโพรซีเดอร์เซิร์ฟเวอร์และฟังก์ชันพร้อมพารามิเตอร์ประเภทที่ไม่แน่นอน (เช่น ไดเรกทอรีวัตถุ, DocumentObjectและอื่นๆ) โดยทั่วไปนี่คือ:

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

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

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

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

• เซิร์ฟเวอร์(ช่องทำเครื่องหมาย โทรเซิร์ฟเวอร์ติดตั้ง)

โมดูลทั่วไปฝั่งเซิร์ฟเวอร์สำหรับการเรียกจากไคลเอนต์ได้รับการตั้งชื่อตามกฎทั่วไปสำหรับการตั้งชื่อออบเจ็กต์ข้อมูลเมตา และจะต้องตั้งชื่อด้วย postfix "คอลเซิร์ฟเวอร์".
ตัวอย่างเช่น: การทำงานกับเซิร์ฟเวอร์ FilesCalling

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

ดูสิ่งนี้ด้วย:ข้อจำกัดในการตั้งค่าสถานะ "การเรียกเซิร์ฟเวอร์" สำหรับโมดูลทั่วไป

2.3. โมดูลทั่วไปของไคลเอ็นต์มีตรรกะทางธุรกิจของลูกค้า (ฟังก์ชันการทำงานที่กำหนดไว้สำหรับลูกค้าเท่านั้น) และมีคุณสมบัติดังต่อไปนี้:

• ลูกค้า (แอปพลิเคชันที่มีการจัดการ))
• ลูกค้า (สมัครปกติ)

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

โมดูลทั่วไปของไคลเอนต์ตั้งชื่อด้วยคำนำหน้า "ลูกค้า".
ตัวอย่างเช่น: การทำงานกับ FilesClient, วัตถุประสงค์ทั่วไปไคลเอนต์

ดูเพิ่มเติมที่: การลดขนาดโค้ดที่ทำงานบนไคลเอ็นต์ให้เหลือน้อยที่สุด

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

• ลูกค้า (แอปพลิเคชันที่มีการจัดการ)
• เซิร์ฟเวอร์(ช่องทำเครื่องหมาย โทรเซิร์ฟเวอร์รีเซ็ต)
• ลูกค้า (สมัครปกติ)
• เข้าร่วมด้านนอก

โมดูลทั่วไปประเภทนี้จะถูกตั้งชื่อด้วย postfix "ไคลเอนต์เซิร์ฟเวอร์".
ตัวอย่างเช่น: การทำงานกับ FilesClient, วัตถุประสงค์ทั่วไปไคลเอนต์เซิร์ฟเวอร์

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

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

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

เพื่อแยกความแตกต่างระหว่างโมดูลทั่วไปของระบบย่อยหนึ่งซึ่งถูกสร้างขึ้นเพื่อใช้ขั้นตอนและฟังก์ชันที่ดำเนินการในบริบทที่แตกต่างกัน ขอแนะนำให้มอบ postfixes ที่อธิบายไว้ก่อนหน้าในย่อหน้า 2.1-2.4.

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

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

โมดูลแอปพลิเคชัน

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

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

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

ตามที่ระบุไว้ข้างต้น โมดูลแอปพลิเคชันจะจัดการเหตุการณ์การเริ่มต้นและการยกเลิกแอปพลิเคชัน ในการจัดการแต่ละเหตุการณ์เหล่านี้ในโมดูลแอปพลิเคชัน มีคู่ของตัวจัดการ Before... และ When... ความแตกต่างระหว่างเหตุการณ์เหล่านี้คือเมื่อรันโค้ดในตัวจัดการ Before... การดำเนินการยังไม่มี เกิดขึ้นและเราสามารถปฏิเสธที่จะดำเนินการได้ นี่คือสิ่งที่ตัวเลือกปฏิเสธมีไว้เพื่อ ในตัวจัดการ On.. การดำเนินการได้เกิดขึ้นแล้ว และเราไม่สามารถปฏิเสธที่จะเปิดแอปพลิเคชันหรือออกจากแอปพลิเคชันได้

โมดูลการเชื่อมต่อภายนอก

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

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

โมดูลเซสชัน

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

ในโมดูลเซสชัน มีเหตุการณ์เดียว “SettingSessionParameters” ซึ่งถูกดำเนินการก่อน แม้กระทั่งก่อนเหตุการณ์โมดูลแอปพลิเคชัน BeforeSystemStartOperation ก็ตาม ส่วนการประกาศตัวแปรและส่วนโปรแกรมหลักไม่พร้อมใช้งาน คุณยังไม่สามารถประกาศวิธีการส่งออกได้ โมดูลถูกคอมไพล์บนฝั่งเซิร์ฟเวอร์

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

โมดูลทั่วไป

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

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

โมดูลแบบฟอร์ม

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

โมดูลวัตถุ

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

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

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

โมดูลตัวจัดการวัตถุ

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

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

สัญลักษณ์บนแผนภาพ: O.M. ลูกค้า - โมดูลทั่วไปของไคลเอนต์; โอ.เอ็ม. เซิร์ฟเวอร์ - โมดูลที่ใช้ร่วมกันของเซิร์ฟเวอร์ ม.ฟ. ลูกค้า - ขั้นตอนลูกค้าของโมดูลแบบฟอร์ม ม.ฟ. เซิร์ฟเวอร์ - ขั้นตอนเซิร์ฟเวอร์ของโมดูลฟอร์ม

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

โดยทั่วไปโมดูลซอฟต์แวร์จะประกอบด้วยสามส่วน:

• พื้นที่ประกาศตัวแปร;
• ขอบเขตของคำอธิบายขั้นตอนและฟังก์ชัน;
• ข้อความหลักของโปรแกรม.

ตัวอย่างโครงสร้างของโมดูลซอฟต์แวร์:

//******************* พื้นที่ประกาศตัวแปร **********************

การส่งออกนามสกุล Perem; - /นี่คือตัวแปรโกลบอล
เปลี่ยนชื่อ นามสกุล; //นี่คือตัวแปรโมดูล
เปเรม ชื่อเต็ม; //นี่เป็นตัวแปรโมดูลและสามารถเข้าถึงได้

//จากขั้นตอนและฟังก์ชันใดๆ ของโมดูลของเรา

//*************** คำอธิบายพื้นที่ของขั้นตอนและฟังก์ชั่น ****************

ขั้นตอน ขั้นตอนที่ 1 ()
ผลรวมของตัวแปร ; - /Result เป็นตัวแปรท้องถิ่น (ตัวแปรขั้นตอน)

รวม = นามสกุล + " "+ ชื่อ + " "+ ชื่อกลาง;

สิ้นสุดขั้นตอน

ฟังก์ชัน ฟังก์ชัน1()

// ตัวดำเนินการฟังก์ชัน

กลับ(นามสกุล + " "+ ชื่อ);

EndFunction

//******************* ข้อความหลักของโปรแกรม ***********************

นามสกุล = "อีวานอฟ";
ชื่อ = "อีวาน";
นามสกุล = "อิวาโนวิช";

//******************************************************************************

ในโมดูลซอฟต์แวร์เฉพาะ พื้นที่ใดพื้นที่หนึ่งอาจหายไป
พื้นที่ประกาศตัวแปรวางจากจุดเริ่มต้นของข้อความโมดูลไปยังคำสั่ง Procedure หรือ Function แรกหรือคำสั่งปฏิบัติการใดๆ ส่วนนี้สามารถมีได้เฉพาะคำสั่งประกาศตัวแปรตัวแปรเท่านั้น

พื้นที่สำหรับอธิบายขั้นตอนและฟังก์ชันวางจากคำสั่ง Procedure หรือ Function แรกไปยังคำสั่งปฏิบัติการใดๆ ที่อยู่นอกเนื้อหาของขั้นตอนหรือคำอธิบายฟังก์ชัน

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

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

โมดูลซอฟต์แวร์แต่ละโมดูลจะถูกรับรู้โดยระบบโดยรวม ดังนั้นขั้นตอนและฟังก์ชันทั้งหมดของโมดูลซอฟต์แวร์จึงดำเนินการในบริบทเดียว

บริบทการดำเนินการโมดูลแบ่งออกเป็นไคลเอนต์และเซิร์ฟเวอร์ นอกจากนี้ โมดูลซอฟต์แวร์บางตัวสามารถคอมไพล์ได้ทั้งบนฝั่งไคลเอ็นต์และฝั่งเซิร์ฟเวอร์

โมดูลแอปพลิเคชัน (มีการจัดการหรือปกติ)

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

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

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

โมดูลการเชื่อมต่อภายนอก

• สามารถมีทั้งหมด 3 พื้นที่
• อยู่ในส่วนรูทของการกำหนดค่า

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

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

โมดูลเซสชัน

• ทำงานบนฝั่งเซิร์ฟเวอร์
• อยู่ในส่วนรูทของการกำหนดค่า

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

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

โมดูลทั่วไป

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

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

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

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

โมดูลแบบฟอร์ม

• สามารถมีทั้งหมด 3 พื้นที่
• ดำเนินการบนเซิร์ฟเวอร์และฝั่งไคลเอ็นต์

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

โครงสร้างของแบบฟอร์มที่ได้รับการจัดการมีส่วนสำหรับการประกาศตัวแปร คำอธิบายขั้นตอนและฟังก์ชัน และข้อความหลักของโปรแกรม (ดำเนินการในขณะที่เตรียมใช้งานแบบฟอร์ม) เราสามารถเข้าถึงเหตุการณ์แบบฟอร์มมาตรฐานผ่านรายการขั้นตอนและฟังก์ชันที่คาดหวังของแบบฟอร์ม (Ctrl+Alt+P)หรือผ่านแผงคุณสมบัติของฟอร์มเอง

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

โมดูลวัตถุ

• สามารถมีทั้งหมด 3 พื้นที่
• ทำงานบนฝั่งเซิร์ฟเวอร์

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

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

โมดูลตัวจัดการวัตถุ

• สามารถมีทั้งหมด 3 พื้นที่
• ทำงานบนฝั่งเซิร์ฟเวอร์

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

โมดูลคำสั่ง

• อาจมีส่วนอธิบายขั้นตอนและฟังก์ชัน
• ดำเนินการบนฝั่งไคลเอ็นต์

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

ในเวอร์ชันใหม่ของ 1C:Enterprise การกำหนดค่าระบบ ฟังก์ชันและขั้นตอนต่างๆ มากมายได้ย้ายจากโมดูลอ็อบเจ็กต์ (เอกสาร ไดเร็กทอรี ฯลฯ) ไปยังโมดูลผู้จัดการ มาดูความแตกต่างระหว่างสองโมดูลนี้กัน

ตามทฤษฎีของการเขียนโปรแกรมเชิงวัตถุ วิธีการของวัตถุแบ่งออกเป็นสองกลุ่ม: แบบคงที่และแบบง่าย วิธีการง่าย ๆ มีสิทธิ์เข้าถึงอินสแตนซ์เฉพาะของคลาสเท่านั้น วิธีการคงที่ไม่สามารถเข้าถึงข้อมูลอ็อบเจ็กต์ แต่ใช้งานได้กับคลาสโดยรวม

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

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

ฟังก์ชัน NewFunction() ส่งออก

ในการใช้ฟังก์ชันดังกล่าวจากโมดูลออบเจ็กต์ คุณต้องมีลิงก์ไปยังออบเจ็กต์ที่ต้องการก่อน จากนั้นรับมันโดยใช้ฟังก์ชัน รับวัตถุ().

ต่อ = วัตถุ ฟังก์ชั่นใหม่() ;

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

ตัวแปรส่งออกตัวแปรใหม่

องค์ประกอบไดเรกทอรี = ไดเรกทอรี ศัพท์. FindByCode("000000001" ) ;
วัตถุ = องค์ประกอบไดเรกทอรี GetObject() ;
วัตถุ ตัวแปรใหม่= ) ;

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

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

ขั้นตอน NewProcedure() ส่งออก

องค์ประกอบไดเรกทอรี = ไดเรกทอรี ศัพท์. ขั้นตอนใหม่();

หรือสำหรับตัวแปร:

ตัวแปรส่งออกตัวแปรใหม่

องค์ประกอบไดเรกทอรี = ไดเรกทอรี ศัพท์. ตัวแปรใหม่;

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

เมื่อใช้โมดูลวัตถุ โค้ดจะมีลักษณะดังนี้:

ฟังก์ชั่นการพิมพ์เอกสาร (ลิงก์) ส่งออก
//คุณต้องส่งลิงก์ไปยังเอกสารเฉพาะไปยังฟังก์ชันนี้
กลับ TabDoc;
EndFunction

บนแบบฟอร์มเอกสาร คุณต้องสร้างขั้นตอนที่จะส่งลิงก์ไปยังเอกสารไปยังฟังก์ชันการพิมพ์

&บนไคลเอนต์
ขั้นตอนการพิมพ์(คำสั่ง)
TabDoc = PrintOnServer();
แท็บหมอ. แสดง() ;
สิ้นสุดขั้นตอน
&บนเซิร์ฟเวอร์
ฟังก์ชั่น PrintOnServer()
Doc = FormAttributesValue("วัตถุ" ) ;
กลับหมอ PrintDocument(วัตถุ ลิงค์);
EndFunction

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

จากจุดยืนด้านประสิทธิภาพ การใช้โมดูลตัวจัดการทุกครั้งที่เป็นไปได้จะดีกว่ามาก ในตัวอย่างของเรา วิธีแก้ไขปัญหาจะมีลักษณะเช่นนี้
ฟังก์ชั่น PrintOnServer()
เอกสารส่งคืน. เอกสารของเรา. พิมพ์เอกสาร(ArrayLinks);
EndFunction

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

ดังนั้นเมื่อใดควรใช้โมดูลอ็อบเจ็กต์ และเมื่อใดจึงควรใช้โมดูลตัวจัดการ

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