การเรียกวิธีการนอกบริบทของออบเจ็กต์การประมวลผล (รายงาน) ในรูปแบบที่ได้รับการจัดการ การเรียกเมธอดที่ไม่อยู่ในบริบทของการประมวลผลออบเจ็กต์ (รายงาน) ในแบบฟอร์มที่ได้รับการจัดการ วิธีการเข้าถึงโมดูลออบเจ็กต์จากแบบฟอร์ม

ในเวอร์ชันใหม่ของ 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 8.3 และ 8.2 ซึ่งจัดเก็บโค้ดโปรแกรมที่มักถูกเรียกในการกำหนดค่า สามารถเรียกใช้ฟังก์ชัน/ขั้นตอนได้จากทุกที่ในการกำหนดค่า (หากเป็นการส่งออก)

วิธีใช้โมดูลที่ใช้ร่วมกัน

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

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

คุณสมบัติของโมดูลทั่วไป

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

รับบทเรียนวิดีโอ 267 บทเรียนบน 1C ฟรี:

มาดูคุณสมบัติของโมดูลทั่วไปกันดีกว่า:

• ทั่วโลก- หากมีการตั้งค่าสถานะ ฟังก์ชันและขั้นตอนจากโมดูลนี้จะพร้อมใช้งานในบริบทส่วนกลาง เหล่านั้น. สามารถเรียกได้ทุกที่ในการกำหนดค่าโดยการเข้าถึงโดยไม่ต้องใช้ชื่อของโมดูลทั่วไป อย่างไรก็ตาม มีการเพิ่มเงื่อนไข - ชื่อของขั้นตอนและฟังก์ชันในโมดูลทั่วไปนี้จะต้องไม่ซ้ำกันภายในบริบทส่วนกลาง
• เซิร์ฟเวอร์— ขั้นตอนและฟังก์ชั่นของโมดูลทั่วไปนี้สามารถดำเนินการได้บนเซิร์ฟเวอร์
• การรวมภายนอก— รหัสโปรแกรมของโมดูลทั่วไปนี้สามารถดำเนินการได้เมื่อเชื่อมต่อโดยแหล่งภายนอก (เช่น COM)
• ลูกค้า (แอปพลิเคชันที่มีการจัดการ)— ขั้นตอนและฟังก์ชันของโมดูลทั่วไปนี้สามารถใช้ในไคลเอ็นต์แบบหนาในโหมดแอปพลิเคชันที่ได้รับการจัดการ
• ลูกค้า (สมัครปกติ)— รหัสโปรแกรมของโมดูลทั่วไปนี้สามารถใช้ในไคลเอนต์แบบหนาในโหมดแอปพลิเคชันปกติ
• โทรเซิร์ฟเวอร์— ธงที่อนุญาตให้ไคลเอ็นต์ใช้ขั้นตอนและฟังก์ชันจากโมดูลทั่วไปนี้
• — หากตั้งค่าเป็น True การตรวจสอบสิทธิ์การเข้าถึงจะถูกปิดใช้งานในโมดูลทั่วไปนี้
• ใช้ซ้ำ— กำหนดการตั้งค่าของค่าที่ส่งคืน หากเปิดใช้งานตัวเลือก หลังจากการดำเนินการครั้งแรก ระบบจะจดจำค่าสำหรับพารามิเตอร์อินพุตเหล่านี้ และจะส่งกลับค่าสำเร็จรูป สามารถรับค่าต่อไปนี้: ไม่ได้ใช้- ปิดตัวลง, ตลอดระยะเวลาการโทร- ตลอดระยะเวลาของขั้นตอนบางอย่าง ตลอดระยะเวลาเซสชัน— จนกว่าผู้ใช้จะปิดเซสชัน (โปรแกรม)

หากคุณกำลังเริ่มเรียนรู้การเขียนโปรแกรม 1C เราขอแนะนำหลักสูตรฟรีของเรา (อย่าลืม

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

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

ในบทความเราจะดูความแตกต่างพื้นฐานระหว่างโมดูลเหล่านี้ทั้งจากด้านทฤษฎีและการใช้ตัวอย่างเชิงปฏิบัติที่เฉพาะเจาะจง

ทฤษฎี

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

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

เรามาต่อจากทฤษฎีไปสู่การปฏิบัติกันดีกว่า

ฝึกฝน

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

ขั้นตอนการพิมพ์ในโมดูลออบเจ็กต์

ในโมดูลอ็อบเจ็กต์ไดเร็กทอรี ให้เพิ่มฟังก์ชันต่อไปนี้:

// ส่งการอ้างอิงไปยังองค์ประกอบไดเร็กทอรีไปยังฟังก์ชันฟังก์ชั่น PrintSelectedProducts (ลิงก์) ส่งออก TabDoc = TabularDocument ใหม่; เค้าโครง = ไดเร็กทอรี สินค้า. GetLayout("เค้าโครง"); คำขอ = คำขอใหม่; ขอ. ข้อความ = " SELECT | สินค้า - การนำเสนอผลิตภัณฑ์ AS,- สินค้า- - มาร์คเดเลชั่น, |- รหัสผู้ขายจาก -ไดเรกทอรี - สินค้า AS สินค้า|ที่ไหน | สินค้า - ลิงค์ B(&อาร์เรย์ผลิตภัณฑ์)

" ; Request. SetParameter(" Array of Products ", Link);

//เลือกตามลิงค์

รหัสโปรแกรมถูกสร้างขึ้นโดยผู้ออกแบบการพิมพ์ สิ่งเดียวที่ควรสังเกตคือการแสดงผลโดยอ้างอิงถึงองค์ประกอบไดเรกทอรี "ผลิตภัณฑ์" ในคำขอ การอ้างอิงถูกส่งผ่านเป็นพารามิเตอร์ไปยังฟังก์ชัน จากการเรียกใช้ฟังก์ชัน "PrintSelectedProducts" เอกสารสเปรดชีตที่มีตำแหน่งผลิตภัณฑ์ที่สมบูรณ์จะถูกส่งกลับ // ติดต่อขั้นตอนเซิร์ฟเวอร์เพื่อรับเอกสารสเปรดชีตที่สร้างขึ้น TabDoc = เซิร์ฟเวอร์การพิมพ์() ; // แสดงเอกสารสเปรดชีตที่สร้างขึ้นแท็บด็อก. แสดง() ; EndProcedure และฟังก์ชัน OnServer PrintServer() // แปลงวัตถุแบบฟอร์มเป็นวัตถุไดเร็กทอรี "ผลิตภัณฑ์" เพื่อเรียกใช้ฟังก์ชันจากโมดูลวัตถุ ObjectItem = FormAttributeValue("วัตถุ" ) ; // เรียกโพรซีเดอร์โมดูลอ็อบเจ็กต์โดยส่งลิงก์ไปยังองค์ประกอบไดเร็กทอรีปัจจุบัน ผลลัพธ์ // กลับสู่ฝั่งไคลเอ็นต์ส่งคืน ObjectProduct PrintSelectedProducts (Object.Link); EndFunction

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

ขั้นตอนการพิมพ์ในโมดูลตัวจัดการ

มาเพิ่มขั้นตอนการส่งออกต่อไปนี้ให้กับโมดูลตัวจัดการไดเรกทอรี:

// ส่งอาร์เรย์ลิงก์ไปยังผลิตภัณฑ์ฟังก์ชั่น PrintSelectedProducts (ArrayProducts) ส่งออก TabDoc = TabularDocument ใหม่; เค้าโครง = ไดเร็กทอรี สินค้า. GetLayout("เค้าโครง"); คำขอ = คำขอใหม่; ขอ. ข้อความ = " SELECT | สินค้า - การนำเสนอผลิตภัณฑ์ AS,- สินค้า- - มาร์คเดเลชั่น, |- รหัสผู้ขายจาก -ไดเรกทอรี - สินค้า AS สินค้า" ; Request. SetParameter(" Array of Products ", Array of Products); // ตั้งค่าการเลือกตามอาร์เรย์ผลลัพธ์ = คำขอ วิ่ง();

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

รหัสโปรแกรมของโมดูลคำสั่งแบบฟอร์ม "พิมพ์" มีลักษณะดังนี้:

& ในขั้นตอนไคลเอนต์ พิมพ์ (คำสั่ง) TabDoc = PrintServer() ; แท็บด็อก. แสดง() ; EndProcedure และฟังก์ชัน OnServer PrintServer() // ส่งอาร์เรย์ของลิงก์ของผลิตภัณฑ์ที่เลือกในรายการไดเร็กทอรี // เข้าสู่ฟังก์ชันโมดูลผู้จัดการ "PrintSelectedProducts"ส่งคืนไดเร็กทอรี สินค้า. PrintSelectedItems(รายการ.รายการSelectedRows); EndFunction

ในกรณีนี้ ผลลัพธ์ของการดำเนินการคำสั่งในโหมด 1C:Enterprise จะเป็นดังนี้:

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

จะใช้อะไร?

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

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

การกำหนดค่าพร้อมตัวอย่างจากบทความ

บทความนี้ยังคงดำเนินต่อไปในซีรีส์ "ขั้นตอนแรกในการพัฒนาบน 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