ปุ่มตัวเลือก แอปพลิเคชันทั่วไป แบบฟอร์มที่ได้รับการจัดการ สวิตช์ แอปพลิเคชันปกติ ปัญหาแบบฟอร์มที่ได้รับการจัดการ 1c กับแบบฟอร์มที่ได้รับการจัดการ

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

อาจจำเป็นต้องมีการแก้ไขแบบฟอร์มโดยทางโปรแกรมในหลายกรณี:

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

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

• ข้อกำหนด;
• คำสั่งท้องถิ่น
• องค์ประกอบ

การดำเนินการทั้งหมดนี้ทำได้บนเซิร์ฟเวอร์เท่านั้น

การปรับรูปร่างแบบเป็นโปรแกรมมีข้อจำกัด:

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

คำสั่งเปลี่ยนรูปแบบ

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

เพิ่ม (< ИмяКоманды >)

ปริมาณ ()

หา (< ИмяКоманды >)

ลบ (< Команда >)

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

ตัวอย่างการทำงานกับคำสั่งแบบฟอร์ม เรามาสร้างคำสั่ง ChangeHistory ใหม่โดยใช้ชื่อ "Change History ... " ซึ่งจะเรียกตัวจัดการ ประวัติการแสดงผล() . การสร้างจะดำเนินการเมื่อมีการเปิดแบบฟอร์ม

&บนเซิร์ฟเวอร์
ขั้นตอน OnCreateOnServer (ความล้มเหลว การประมวลผลมาตรฐาน)
ทีม = คำสั่ง เพิ่ม( "ประวัติศาสตร์การเปลี่ยนแปลง");
ทีม . การกระทำ = ;
ทีม . ชื่อเรื่อง = "ประวัติศาสตร์แห่งการเปลี่ยนแปลง...";
สิ้นสุดขั้นตอน
&ที่ลูกค้า
ขั้นตอน Connected_DisplayHistory (Command)
// การดำเนินการคำสั่ง
สิ้นสุดขั้นตอน

ตัวจัดการคำสั่งจะต้องอยู่ในแบบฟอร์มและมีคำสั่งการคอมไพล์ &AtClient

การเปลี่ยนแปลงรายละเอียดแบบฟอร์ม

การอ่านองค์ประกอบของแอตทริบิวต์แบบฟอร์มจะดำเนินการโดยฟังก์ชัน รับรายละเอียด(< Путь >) ที่ส่งคืนอาร์เรย์ประเภท FormAttributes พารามิเตอร์ฟังก์ชันระบุเส้นทางไปยังแอตทริบิวต์พาเรนต์ (เป็นสตริง) หากละเว้นพารามิเตอร์หรือระบุสตริงว่าง ระบบจะส่งคืนข้อมูลรับรองระดับบนสุด

การเปลี่ยนรายละเอียดทำได้โดยวิธีการ แก้ไขข้อกำหนด(<รายละเอียดที่เพิ่มเข้ามา>, <รายละเอียดที่ถอดออกได้>) วัตถุ แบบฟอร์มที่ได้รับการจัดการ. ตัวเลือก รายละเอียดที่เพิ่มเข้ามาและ รายละเอียดที่ถอดออกได้อาร์เรย์ที่มีองค์ประกอบของประเภท Form Requisite จะถูกส่งผ่าน

ความสนใจ!

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

มาสร้างแอตทริบิวต์แบบฟอร์มใหม่ชื่อผู้ซื้อ:

AddedAttributes = อาร์เรย์ใหม่;
รายละเอียดที่เพิ่มเข้ามา เพิ่ม (แอตทริบิวต์ฟอร์มใหม่("ผู้ซื้อ", คำอธิบายประเภทใหม่ ("DirectoryReference.Counterparties"), "ลูกค้า");

// การเปลี่ยนแปลงองค์ประกอบของแอตทริบิวต์
);

การเปลี่ยนองค์ประกอบของแบบฟอร์ม

เพื่อจัดการองค์ประกอบขององค์ประกอบของวัตถุ แบบฟอร์มที่ได้รับการจัดการมีคอลเลกชัน องค์ประกอบ. การรวบรวมมีหลายวิธี:

แทรก (< Имя>, < ТипЭлемента>, < Родитель>, < Элемент >)

เพิ่ม (< Имя>, < ТипЭлемента>, < Родитель >)

ปริมาณ ()

หา (< Имя >)

เคลื่อนไหว(< Элемент>, < Родитель>, < МестоРасположения >)

ลบ (< Элемент >)

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

• แบบฟอร์มกลุ่ม;
• แบบฟอร์มตาราง;
• ฟอร์มฟิลด์;
• ปุ่มแบบฟอร์ม

คุณสามารถกำหนดตัวจัดการเหตุการณ์ให้กับองค์ประกอบแบบฟอร์มโดยทางโปรแกรมได้ เพื่อจุดประสงค์นี้จึงใช้วิธีการ เซตแอคชั่น(< ИмяСобытия>, < Действие >) .

มาดูตัวอย่างการใช้งานจริงทั่วไปบางส่วนของการทำงานกับคำสั่ง คุณลักษณะ และองค์ประกอบของแบบฟอร์ม

การเพิ่มคำสั่งและปุ่มที่เกี่ยวข้อง:

//สร้างทีม
ทีม = คำสั่ง เพิ่ม( "ประวัติศาสตร์การเปลี่ยนแปลง");
ทีม . การกระทำ = "เชื่อมต่อ_ประวัติการแสดงผล"; // แบบฟอร์มจะต้องมีขั้นตอนที่มีชื่อที่ระบุ
ทีม . หัวข้อ = "ประวัติศาสตร์แห่งการเปลี่ยนแปลง...";
// สร้างปุ่มและเชื่อมโยงกับคำสั่ง
องค์ประกอบ = รายการ เพิ่ม( "ประวัติศาสตร์การเปลี่ยนแปลง", พิมพ์("ปุ่มแบบฟอร์ม" ));
Element.CommandName = "ประวัติศาสตร์การเปลี่ยนแปลง";

การเพิ่มแอตทริบิวต์และช่องป้อนข้อมูลที่เกี่ยวข้อง:

// คำอธิบายรายละเอียดเพิ่มเติม
AddedAttributes = อาร์เรย์ใหม่;
รายละเอียดที่เพิ่มเข้ามา เพิ่ม(แอตทริบิวต์แบบฟอร์มใหม่ ("ผู้ซื้อ" คำอธิบายประเภทใหม่ ( “ลิงค์อ้างอิงคู่สัญญา”), "ลูกค้า" ));
// การเปลี่ยนองค์ประกอบของแอตทริบิวต์
แก้ไขแอตทริบิวต์ (AddedAttributes);
// การสร้างช่องป้อนข้อมูลและเชื่อมโยงไปยังแอตทริบิวต์
องค์ประกอบ = รายการ เพิ่ม("ลูกค้า" , พิมพ์("FormField" ));
องค์ประกอบ . มุมมอง = ViewFormFields ช่องรายการ;
องค์ประกอบ . เส้นทางสู่ข้อมูล= "ผู้ซื้อ" ;

การกำหนดตัวจัดการเหตุการณ์ให้กับองค์ประกอบแบบฟอร์ม:

รายการผู้ซื้อ เซ็ตแอคชั่น("เมื่อมีการเปลี่ยนแปลง" , "ปลั๊กอิน_ผู้ซื้อเมื่อเปลี่ยน");

&ที่ลูกค้า
ขั้นตอน Plugin_BuyerOnChange(องค์ประกอบ )
// การกระทำของเหตุการณ์
สิ้นสุดขั้นตอน

ความสนใจ!

ขั้นตอนที่ติดตั้งเป็นตัวจัดการเหตุการณ์จากโค้ดโดยใช้วิธีการ เซ็ตแอคชั่น()ขอแนะนำให้ใช้คำนำหน้า Connected_

ความสนใจ!

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

และ Data Transfer Object ไปยังโครงสร้างโค้ด แบบฟอร์มที่ได้รับการจัดการในสภาพแวดล้อม 1C 8.2

การแนะนำ

เริ่มต้นด้วยคำอธิบายสั้น ๆ เกี่ยวกับแนวคิดของ "แบบฟอร์มที่ได้รับการจัดการ" และแนวคิดที่เกี่ยวข้องของแพลตฟอร์ม 1C ผู้เชี่ยวชาญด้านแพลตฟอร์มสามารถข้ามส่วนนี้ได้

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

• Thick Client (โหมดการเปิดตัวปกติและแบบมีการจัดการ)
• ไคลเอ็นต์แบบบาง
• เว็บไคลเอ็นต์

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

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

ต่อไปนี้เป็นคำสั่งสำหรับวิธีการรวบรวมแบบฟอร์ม:

• &ที่ลูกค้า
• &บนเซิร์ฟเวอร์
• &บนเซิร์ฟเวอร์ไม่มีบริบท
• &ที่ไคลเอนต์ที่เซิร์ฟเวอร์ไม่มีบริบท

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

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

มากำหนดปัญหากันดีกว่า

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

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

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

ทำไมคุณถึงต้องมีโครงสร้างรหัส?

• ลดความซับซ้อนของการบำรุงรักษา
• ลดความซับซ้อนในการเรียนรู้
• แก้หลักการทั่วไป/สำคัญ/สำเร็จ
• …ทางเลือกของคุณ

เหตุใดมาตรฐานการพัฒนาที่มีอยู่จาก 1C จึงไม่ช่วยอะไร

มาดูหลักการที่เผยแพร่บนดิสก์ ITS และใน "คำแนะนำสำหรับนักพัฒนา ... " ต่างๆ ที่แนะนำเมื่อเขียนฟอร์มที่ได้รับการจัดการ

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

สโลแกนเหล่านี้เป็นเรื่องจริง แต่จะตระหนักได้อย่างไร? วิธีลดจำนวนการโทรให้เหลือน้อยที่สุดการเขียนโปรแกรมในโหมดไคลเอนต์ - เซิร์ฟเวอร์หมายความว่าอย่างไร?

รูปแบบการออกแบบหรือภูมิปัญญารุ่นต่อรุ่น

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

• ซุ้มระยะไกล(ต่อไปนี้จะเรียกว่าอินเทอร์เฟซการเข้าถึงระยะไกล)
• ออบเจ็กต์การถ่ายโอนข้อมูล(ต่อไปนี้จะเรียกว่า Data Transfer Object)

ถ้อยคำถึงมาร์ติน ฟาวเลอร์ คำบรรยายของเขาเกี่ยวกับหลักธรรมเหล่านี้:

• … แต่ละวัตถุที่อาจมีไว้สำหรับการเข้าถึงระยะไกลจะต้องมี อินเทอร์เฟซที่มีรายละเอียดต่ำซึ่งจะลดจำนวนการโทรที่จำเป็นในการดำเนินการตามขั้นตอนเฉพาะ … แทนที่จะขอใบแจ้งหนี้และคะแนนทั้งหมดแยกกัน จำเป็นต้องอ่านและอัปเดตทุกประเด็นของใบแจ้งหนี้ในการโทรเพียงครั้งเดียว สิ่งนี้ส่งผลต่อโครงสร้างทั้งหมดของออบเจ็กต์...ข้อควรจำ: อินเทอร์เฟซการเข้าถึงระยะไกล ไม่มีตรรกะของโดเมน.
• ... ถ้าฉันเป็นแม่ที่เอาใจใส่ ฉันจะบอกลูกอย่างแน่นอนว่า: “อย่าเขียนวัตถุการถ่ายโอนข้อมูล!” ในกรณีส่วนใหญ่ ออบเจ็กต์การย้ายข้อมูลจะไม่มีอะไรมากไปกว่า สนามป่อง… คุณค่าของสัตว์ประหลาดที่น่าขยะแขยงนี้อยู่ที่ความเป็นไปได้เท่านั้น ส่งข้อมูลหลายรายการผ่านเครือข่ายในการโทรครั้งเดียว- เทคนิคที่มีความสำคัญอย่างยิ่งสำหรับระบบแบบกระจาย

ตัวอย่างเทมเพลตในแพลตฟอร์ม 1C

API ที่นักพัฒนาสามารถใช้งานได้เมื่อพัฒนาแบบฟอร์มที่ได้รับการจัดการประกอบด้วยตัวอย่างมากมายของหลักการเหล่านี้
ตัวอย่างเช่น วิธีการ OpenForm() ซึ่งเป็นอินเทอร์เฟซ "หยาบ" ทั่วไป
OpenParameters = โครงสร้างใหม่ ("พารามิเตอร์1, พารามิเตอร์2, พารามิเตอร์3", ค่า1, ค่า2, ค่า3); แบบฟอร์ม = OpenForm (ชื่อแบบฟอร์ม, พารามิเตอร์ของ Open);
เทียบสไตล์ v8.1
แบบฟอร์ม = GetForm(ชื่อแบบฟอร์ม); Form.Parameter1 = ค่า1; Form.Parameter2 = ค่า2; แบบฟอร์มเปิด();

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

• โครงสร้างรูปแบบข้อมูล
• DataFormsCollection
• DataFormStructureCollection
• DataFormsTree

การแปลงออบเจ็กต์ระบบการถ่ายโอนข้อมูลเป็นประเภทแอปพลิเคชันและในทางกลับกันทำได้โดยวิธีการต่อไปนี้:

• ค่าVDataForm()
• FormDataToValue()
• คัดลอกแบบฟอร์มข้อมูล()
• ค่าVFormProps()
• FormAttributeToValue()

บ่อยครั้งมีการใช้การแปลงที่ชัดเจนเมื่อปรับเปลี่ยนโซลูชันที่มีอยู่ วิธีการอาจคาดหวัง (คุณลักษณะ) พารามิเตอร์อินพุต เช่น ValueTable แทนที่จะเป็นFormDataCollection หรือวิธีการถูกกำหนดในบริบทของวัตถุแอปพลิเคชัน และไม่พร้อมใช้งานสำหรับการโทรโดยตรงจากแบบฟอร์ม
ตัวอย่าง 1C v8.1:
// บนไคลเอนต์ในบริบทของแบบฟอร์ม FillUsersCache(DepartmentReference)
ตัวอย่าง 1C v8.2:
// บนเซิร์ฟเวอร์ในบริบทของรูปแบบ ProcessingObject = FormAttributeToValue("Object"); ProcessingObject.FillCacheUsers (DepartmentReference); ValueVFormAttribute(ProcessingObject, "Object");

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

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

ตัวอย่าง: วิธีการยอมรับรายการคำสั่งซื้อเพื่อเปลี่ยนสถานะและส่งคำอธิบายข้อผิดพลาดไปยังไคลเอนต์
&OnServerWithoutContext ฟังก์ชัน ServerChangeOrderStatus (คำสั่งซื้อ, สถานะใหม่) ข้อผิดพลาด = การจับคู่ใหม่ (); // [คำสั่งซื้อ] [คำอธิบายข้อผิดพลาด] สำหรับแต่ละคำสั่งซื้อจากคำสั่งซื้อ Loop StartTransaction (); พยายาม DocOb = Order.GetObject(); …. การกระทำอื่นๆ อาจไม่ใช่แค่กับคำสั่ง... ข้อยกเว้น CancelTransaction(); Errors.Insert(คำสั่งซื้อ, คำอธิบายข้อผิดพลาด()); สิ้นสุดความพยายาม; สิ้นสุดรอบ; กลับข้อผิดพลาด; EndFunction // ServerChangeOrderStatus()

การวางโครงสร้างโค้ด

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

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

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

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

//////////////////////////////////////////////////////////////////////////////// // <(c) Автор="" วันที่ =""/> // <Описание> // // //////////////////////////////////////////////// ////////////////////////////// // ตัวแปรโมดูล //////////////// //////////////////////////////////////////////// ////////////// // บนเซิร์ฟเวอร์ //********* เหตุการณ์บนเซิร์ฟเวอร์ ******* &บนขั้นตอนเซิร์ฟเวอร์ในการสร้างบนเซิร์ฟเวอร์ (ล้มเหลว StandardProcessing) // แทรกเนื้อหาของตัวจัดการ EndProcedure //********* REMOTE ACCESS INTERFACE ******* //******* ตรรกะทางธุรกิจบนเซิร์ฟเวอร์ ****** * ///////// //////////////////////////////////////// ////////// ///////////////////// // วิธีไคลเอนต์และเซิร์ฟเวอร์ทั่วไป //////////// /////////////////////////////////////////////////// //////////// //////// // เกี่ยวกับลูกค้า //********* ตรรกะทางธุรกิจกับลูกค้า ******* //*** **** คำสั่ง ******* //******* เหตุการณ์ที่เกิดขึ้นกับลูกค้า ****** ////////////////// //////////////////////////////////////////////// //////////// / / ผู้ดำเนินการโปรแกรมหลัก

คำถามที่เกี่ยวข้อง

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

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

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

เช่น คู่มือ ศัพท์อาจมีหลายรูปแบบที่จะใช้เพื่อวัตถุประสงค์เฉพาะ - การแก้ไของค์ประกอบไดเร็กทอรี การแสดงรายการ ฯลฯ :

นอกจากนี้ อาจมีแบบฟอร์มทั่วไปที่ไม่อยู่ในออบเจ็กต์การกำหนดค่าเฉพาะ - แบบฟอร์มทั่วไป

แบบฟอร์มพื้นฐาน

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

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

และเอกสาร การรับสินค้าและบริการองค์ประกอบของแบบฟอร์มหลักจะแตกต่างกัน:

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

แบบฟอร์มที่สร้างขึ้นโดยอัตโนมัติ

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

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

การเชื่อมโยงแบบฟอร์มกับข้อมูล

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

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

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

โครงสร้างแบบฟอร์ม

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

ส่วนของแบบฟอร์มที่แสดง (ผู้ใช้มองเห็นได้) อธิบายว่าเป็นแผนผังที่มีองค์ประกอบของแบบฟอร์ม

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

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

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

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

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

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

แอปพลิเคชัน 1C ปกติ (แบบฟอร์มปกติ อินเทอร์เฟซปกติ เวอร์ชัน 1C 8.2)

ใน 1C 8.2 ทำงานได้เท่านั้น ด้วยรูปแบบปกติในโหมดแอปพลิเคชันปกติ. ภาพด้านล่างแสดงฐานในโหมดการทำงาน "แอปพลิเคชัน 1C ปกติ" (รูปแบบปกติ)

แอปพลิเคชันที่ได้รับการจัดการ 1C (แบบฟอร์มที่ได้รับการจัดการ, อินเทอร์เฟซที่ได้รับการจัดการ, เวอร์ชัน 1C 8.3)

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

อะไรคือความแตกต่างระหว่างแอปพลิเคชัน 1C ปกติและแอปพลิเคชันที่ได้รับการจัดการ?

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

Klyuev V.V.

http://prof1c.kklab.ru

การทำงานกับสวิตช์

ฉันขอให้คุณคำนึงถึงผู้ใช้บริการเว็บไซต์ทุกคน - ฉันวางเนื้อหาไว้ในส่วนผู้เริ่มต้น !!!

8.2 แบบฟอร์มที่ได้รับการจัดการ

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

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

เรามาสร้างไดเร็กทอรีใหม่และเพิ่มอุปกรณ์ประกอบฉาก "Props1" ด้วยประเภท "Boolean"

ตอนนี้ไปที่แท็บแบบฟอร์มและเพิ่มแบบฟอร์มใหม่

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

แล้วเราทำอะไรผิดล่ะ?
ลองดูคุณสมบัติของอุปกรณ์ประกอบฉากเพื่อดูว่ามีการสลับไปยังมุมมองของตัวควบคุมหรือไม่
และเราพบว่า Switch Field ไม่อยู่ที่นี่! (เราผิดตรงไหน?

เห็นได้ชัดว่าลักษณะที่ปรากฏของตัวควบคุมบนแบบฟอร์มนั้นขึ้นอยู่กับประเภทข้อมูล ให้กลับไปที่คุณสมบัติของแบบฟอร์ม นั่นคือแท็บรายละเอียด และเปลี่ยนคุณสมบัติของแอตทริบิวต์ของเรา - กล่าวคือประเภท "บูลีน" เป็นประเภท "ตัวเลข"

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

ตอนนี้ดูฟอร์มสิ่งที่เราเห็น:

เราเห็น - ค่าเริ่มต้น 3 ปุ่ม, ปุ่มตัวเลือก 3 ปุ่ม แต่เราต้องการสองปุ่ม ไปที่คุณสมบัติของอุปกรณ์ประกอบฉากอีกครั้งและดูคุณสมบัติ "จำนวนคอลัมน์" ที่นั่น

สำหรับ 2 - ตั้งค่าจำนวนคอลัมน์ - 2

นี่อาจหยุดโปรแกรมเมอร์ที่เหนื่อยล้าได้นิดหน่อย)) แต่ตอนนี้ทั้งเขาและเรารู้แล้ว!

8.2 รูปแบบทั่วไป

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

ลองมาดูตัวอย่างกัน มีเอกสารสำหรับการปรับใบเสร็จรับเงินใน 1C SCP - มีอยู่จริง ครั้งหนึ่งเราจำเป็นต้องเพิ่มสวิตช์เพื่อให้มีการผ่านรายการบัญชีที่แตกต่างกันเล็กน้อย มีปัญหาอะไรก็ดูเหมือนจำเป็น จำเป็น เราก็จะทำ แต่แบบฟอร์มนี้มีปุ่มตัวเลือกอยู่แล้ว 2 ปุ่ม

นี่คือลักษณะที่เราต้องแนบสวิตช์เพิ่มเติม

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

ดูเหมือนว่าทุกอย่างจะง่าย เราสร้างแอตทริบิวต์ใหม่โดยมีประเภท - "หมายเลข" และใส่สวิตช์ 2 ตัวซึ่งหนึ่งในนั้นจะสามารถเขียนข้อมูลไปยังแอตทริบิวต์ได้และอีกอันจะไม่สามารถเขียนได้

เพิ่มการควบคุมใหม่ - Switch ในตารางที่มีหมายเลขและคำอธิบายของสวิตช์ ให้เพิ่ม Switch2 ตั้งค่า Switch1 เป็นอันแรกในกลุ่มแล้วกดตกลง เราวางตัวควบคุมที่สร้างขึ้นบนแบบฟอร์ม อัพเดตการกำหนดค่าฐานข้อมูล (F7) และเรียกใช้การดีบัก

เมื่อดำเนินการ (เมื่อสร้างเอกสารใหม่ในโหมด 1C:Enterprise) เราจะเห็นว่าไม่ว่าเราจะพยายามคลิกที่ Switch2 หนักแค่ไหนก็ไม่มีอะไรเกิดขึ้น องค์ประกอบไม่ทำงานเท่าที่ควร มีคุณสมบัติหนึ่งที่นี่
กลับไปที่ตัวกำหนดค่า เลือกรายการในเมนู แบบฟอร์ม -> การตั้งค่าลำดับการแวะผ่าน ... (สิ่งสำคัญคือต้องเปิดแบบฟอร์มบนหน้าจอ)

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

ตกลง. อัปเดตการกำหนดค่าแล้วลองเรียกใช้
ยอดเยี่ยม. ทุกอย่างทำงานได้

ตัวเลือกเสริม - วิดีโอ (ไม่มีเสียง ดังนั้นทุกอย่างชัดเจน)