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

โดยผู้ดูแลระบบ.

การเรียนรู้ C# นั้นช้า แต่มันก็ดำเนินต่อไปอย่างซื่อสัตย์ เมื่อเร็วๆ นี้ ฉัน
ยกตัวอย่างวิธีการเปิดอีกรูปแบบหนึ่งใน Visual C# โดยหลักการแล้วทุกอย่างก็เรียบง่าย

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

เริ่มต้นด้วยการตั้งค่าข้อมูลเริ่มต้น (เริ่มต้น)

ดังนั้น. เรามีแบบฟอร์มใบสมัครหลัก:

ในแบบฟอร์มนี้ยังมีกล่องข้อความชื่อ TBDialog และปุ่มปุ่มที่เราควรคลิก:

1. ส่งผ่านค่าของคุณสมบัติข้อความจาก TBDialog ไปยัง TBMain
2. ปิด fDialog;

ตอนนี้เรามาดูกระบวนการทั้งหมดตามลำดับ

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

ตอนนี้ TBMain จะปรากฏในวัตถุอื่น เดินหน้าต่อไป เพื่อที่จะเปิดแบบฟอร์มในโหมดโมดอล เราจำเป็นต้องใช้หนึ่งในสองตัวเลือกสำหรับเมธอด ShowDialog():

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

ตัวอย่างเช่น ลองใช้เวอร์ชันที่สองของเมธอด ShowDialog() และแสดงรูปแบบที่สองแบบโมเดอเรเตอร์ เมื่อต้องการทำเช่นนี้ เราจะเขียนสิ่งต่อไปนี้:

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

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

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

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

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

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

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

การใช้ระบบ; ใช้ System.Collections.Generic; ใช้ System.Linq; โดยใช้ System.Windows.Forms; เนมสเปซ From1FormTo2 ( โปรแกรมคลาสคงที่ ( // จุดเข้าหลักสำหรับแอปพลิเคชัน static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) ) )

โค้ดฟอร์มหลักมีลักษณะดังนี้:

การใช้ระบบ; ใช้ System.Collections.Generic; โดยใช้ System.ComponentModel; ใช้ System.Data; โดยใช้ระบบการวาดภาพ; ใช้ System.Linq; ใช้ System.Text; โดยใช้ System.Windows.Forms; เนมสเปซ From1FormTo2 ( MainForm คลาสบางส่วนสาธารณะ: แบบฟอร์ม ( // รูปแบบที่สอง SecondForm SecondForm; // ตัวสร้าง MainForm สาธารณะ () ( InitializeComponent (); ) // ตัวจัดการเหตุการณ์การถ่ายโอนข้อมูล // จากแบบฟอร์มหลักไปยังโมฆะส่วนตัวที่สอง btn_mainForm_Click (วัตถุ ผู้ส่ง EventArgs e) ( SecondForm = new SecondForm(tb_mainForm.Text.Trim()); SecondForm.ShowDialog(); if (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = SecondForm.ReturnData(); ) ) )

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

ตอนนี้ส่วนที่น่าสนใจที่สุดคือโค้ดของแบบฟอร์มที่สอง:

การใช้ระบบ; ใช้ System.Collections.Generic; โดยใช้ System.ComponentModel; ใช้ System.Data; โดยใช้ระบบการวาดภาพ; ใช้ System.Linq; ใช้ System.Text; โดยใช้ System.Windows.Forms; เนมสเปซ From1FormTo2 ( สาธารณะบางส่วนคลาส SecondForm: แบบฟอร์ม ( //ตัวสร้างมากเกินไป สาธารณะ SecondForm(ข้อมูลสตริง) ( InitializeComponent(); tb_secondForm.Text = data; ) // ตัวจัดการเหตุการณ์การถ่ายโอนข้อมูล // จากแบบฟอร์มที่สองไปยังโมฆะส่วนตัวหลัก btn_secondForm_Click (ผู้ส่งวัตถุ EventArgs e) ( this.DialogResult = DialogResult.OK; ) // วิธีการสาธารณะสำหรับการเข้าถึง // ช่องข้อความของแบบฟอร์มนี้ สตริงสาธารณะ ReturnData() ( return (tb_secondForm.Text.Trim()); ) ) )

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

(secondForm .DialogResult == DialogResult .OK)

รูปแบบแรกจึงเรียกเมธอด SecondForm.ReturnData()เราตั้งค่าฟิลด์ข้อความของแบบฟอร์มแรกเป็นค่าของฟิลด์ข้อความของแบบฟอร์มที่สอง

ฉันคิดว่าการดำเนินการของวิธีนี้ไม่ต้องการคำอธิบายอีกต่อไป เพียงส่งคืนข้อความจากฟิลด์ข้อความเดียวโดยยังคงความเป็นส่วนตัวไว้

ด้วยเหตุนี้ เราจึงถ่ายโอนข้อมูลไปยังรูปแบบที่สองตั้งแต่รูปแบบแรกและจากรูปแบบที่สองไปยังรูปแบบแรก โดยไม่ละเมิดหลักการของการห่อหุ้ม

ลองป้อนข้อความ "aaa" ลงในช่องข้อความของแบบฟอร์มแรกแล้วคลิกปุ่ม คุณจะเห็นข้อความนี้ในช่องข้อความในรูปแบบที่สองที่เปิดขึ้น ลองเปลี่ยนข้อความเป็น “aaa ppp” แล้วคลิกที่ปุ่ม คุณจะเห็นว่าหลังจากปิดแบบฟอร์มที่สองแล้ว ข้อความนี้จะปรากฏในช่องข้อความของแบบฟอร์มหลักอย่างไร

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

แม้ว่าความคิดเห็นของฉันเกี่ยวกับ Visual Studio ของ Microsoft จะยังคงเหมือนเดิม แต่บางครั้งคุณต้องทำอะไรบางอย่างกับมัน หากเราตกลงกับความจริงที่ว่าเราเขียน ไม่ใช่ในภาษา C++ แต่ในสิ่งที่เรียกว่า C++/CLI การทำงานกับองค์ประกอบภาพที่คุ้นเคยจะไม่แตกต่างจากสภาพแวดล้อม Borland เดียวกันมากนัก แต่สามารถสร้างปัญหาได้เมื่อเทียบกับ Builder ลองพิจารณาสถานการณ์ทั่วไป 3 ประการในการทำงานกับแอปพลิเคชันที่มีมากกว่าหนึ่งรูปแบบ สภาพแวดล้อมตัวอย่างคือ Visual C++ 2010 Express ฟรี โดยถือว่าแบบฟอร์มหลักมีชื่อเริ่มต้นคือ Form1

ตัวอย่างของการสร้างและการเรียกแบบฟอร์มโดยทางโปรแกรม

รหัสนี้สามารถดำเนินการได้ เช่น โดยการคลิกปุ่มในรูปแบบหลัก Form1

แบบฟอร์ม ^ form2 = แบบฟอร์ม gcnew (); ปุ่ม ^ button2 = ปุ่ม gcnew (); button2->ข้อความ = L"ตกลง"; ปุ่ม 2 -> ตำแหน่ง = จุด (10,10); form2->Text = L"หน้าต่างของฉัน"; form2->HelpButton = จริง; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; form2->StartPosition = FormStartPosition::CenterScreen; form2->การควบคุม->เพิ่ม(button2); form2->ShowDialog();

หากต้องการเพิ่มตัวจัดการสำหรับการคลิกปุ่มที่สร้างโดยทางโปรแกรม button2 เพียงเขียนไว้หน้าบรรทัดสุดท้ายของโค้ด:

Button2->คลิก += gcnew System::EventHandler(นี่ &Form1::button2_Click);

ก่อนที่จะเรียกเมธอด form2->ShowDialog() หรือ form2->Show()

ในกรณีนี้ รหัสตัวจัดการจะอยู่ในโมดูลปัจจุบัน Form1.h:

ส่วนตัว: System::Void button2_Click (System::Object^ ผู้ส่ง System::EventArgs^ e) ( MessageBox::Show("Here"); )

เรียกแบบฟอร์มอื่นจากแบบฟอร์มหลัก

ในเมนู เลือกโครงการ - เพิ่มองค์ประกอบใหม่ - แบบฟอร์ม - ชื่อ Form2

มาเพิ่มโอเปอเรเตอร์กัน

#รวม "Form2.h"

ก่อนเนมสเปซแรกใน Form1.h (นั่นคือ ที่จุดเริ่มต้นของไฟล์)

เรามารวมตัวชี้ไปยังอินสแตนซ์ของคลาสในส่วนสาธารณะของคลาส Form1:

แบบฟอร์ม2^F2;

มาเพิ่มโค้ดที่เราต้องสร้างและเรียกแบบฟอร์มที่สอง:

F2=gcnewForm2(); F2->แสดง();

หากต้องการลบแบบฟอร์มที่สองโดยทางโปรแกรม รหัสต่อไปนี้จะเหมาะสม:

ลบ F2;

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

มาอธิบายข้อมูลที่จำเป็นในรูปแบบคลาส Form1 (นี่คือชื่อและเนมสเปซของโครงการ Tabulator หากจำเป็น ให้แทนที่ด้วยของคุณเอง):

ค่าคงที่ int MAX_FORMS = 100; //จำนวนแบบฟอร์มสูงสุด int FormCount; //สร้างอาร์เรย์ตัวนับ ^F2; //ชี้ไปที่อาร์เรย์ของแบบฟอร์ม

จากนั้นเราเริ่มต้นข้อมูลโดยใช้เหตุการณ์ Load ของแบบฟอร์มหลัก:

แบบฟอร์มนับ=0; F2 = อาร์เรย์ gcnew (MAX_FORMS);

จากนั้นเราจะนำโค้ดไปสร้างแบบฟอร์มถัดไป

ถ้า(FormCount แสดง(); ) else MessageBox::Show("มีรูปแบบมากเกินไป!");

และการกำจัด:

ถ้า (FormCount) ( ลบ F2; FormCount--; )

หากเราต้องการสร้างแบบฟอร์มลูกโดยไม่แยกจากกัน แต่อยู่ในแบบฟอร์มหลัก ดังนั้นในคุณสมบัติของ Form1 เราต้องระบุว่าเป็น "บรรพบุรุษ" (ตั้งค่าคุณสมบัติ IsMdiParent = true) และก่อนที่จะแสดงแบบฟอร์มลูกโดยใช้ ตัวดำเนินการ F2->Show() ทำเครื่องหมายว่าเป็นรายการย่อย Form1:

F2->MdiParent = นี่;

เรียกวิธีแบบฟอร์มหลักจากแบบฟอร์มลูก

เราแทบจะไม่สามารถทำได้โดยไม่ต้องใช้ไฟล์ .cpp ซึ่งถือว่าไม่เลว - โดยทั่วไปการเขียนโค้ดในไฟล์ .h จะทำให้ระบบ C ที่ถูกต้องเสียหาย :)

มาอธิบายกระบวนการทีละขั้นตอนกัน

1) มี 2 รูปแบบ - Form1 และ Form2 บน Form1 จะมีปุ่ม (button1 จะเปิดแบบฟอร์มที่สอง) และ Label (label1 ที่นี่เราจะเปลี่ยนข้อความ) บน Form2 - button1 เมื่อคลิก ข้อความใน label1 จะเปลี่ยน

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

3) ประกาศวิธีการ Set สาธารณะใน Form1.h เพื่อให้คุณสามารถเปลี่ยนข้อความของ label1 (สามารถเขียนโค้ดที่ส่วนท้ายของไฟล์ หลังจาก #pragma endregion):

สาธารณะ: ชุดโมฆะ (สตริง ^ ข้อความ) ( label1->Text = text; )

4) ในไฟล์ Form2.h เรารวม Form1.h (ที่จุดเริ่มต้น):

#รวม "Form1.h"

และสร้าง Constructor ที่จะยอมรับและบันทึกลิงก์ไปยังแบบฟอร์มแรกเพื่อใช้ต่อไป:

Form2(Form1^ parent) ( InitializeComponent(); parentForm = parent; ) //คุณสามารถเขียนลิงค์ด้านล่างได้ทันที: private: Form1^ parentForm;

5) เมื่อคลิกปุ่มใน Form2 เราจะเรียกวิธี Set ของแบบฟอร์มหลัก:

ส่วนตัว: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) ( parentForm->Set("hello from form2"); parentForm->Show(); this->Hide(); )

6) ยังคงเปิดแบบฟอร์มที่สองในรูปแบบแรก ในการดำเนินการนี้ เราย้ายตัวจัดการการคลิกปุ่มจาก Form1.h ไปที่ Form1.cpp และในไฟล์ .h เราจะเหลือเพียงการประกาศเท่านั้น

อัปเดตล่าสุด: 31/10/2558

หากต้องการเพิ่มแบบฟอร์มอื่นให้กับโปรเจ็กต์ ให้คลิกขวาที่ชื่อโปรเจ็กต์ในหน้าต่าง Solution Explorer และเลือก Add->Windows Form...

ลองตั้งชื่อฟอร์มใหม่บ้าง เช่น Form2.cs:

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

โมฆะส่วนตัว button1_Click (ผู้ส่งวัตถุ EventArgs e) ()

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

โมฆะส่วนตัว button1_Click (ผู้ส่งวัตถุ EventArgs e) ( Form2 newForm = new Form2(); newForm.Show(); )

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

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

การใช้ระบบ; ใช้ System.Collections.Generic; โดยใช้ System.ComponentModel; ใช้ System.Data; โดยใช้ระบบการวาดภาพ; ใช้ System.Linq; ใช้ System.Text; ใช้ System.Threading.Tasks; โดยใช้ System.Windows.Forms; เนมสเปซ HelloApp ( คลาสสาธารณะบางส่วน Form2: ฟอร์ม ( public Form2() ( InitializeComponent(); ) สาธารณะ Form2(Form1 f) ( InitializeComponent(); f.BackColor = Color.Yellow; ) ) )

ที่จริงแล้ว เราเพิ่งเพิ่มตัวสร้างใหม่ที่นี่ public Form2(Form1 f) ซึ่งเราได้แบบฟอร์มแรกและตั้งค่าพื้นหลังเป็นสีเหลือง ตอนนี้เรามาดูโค้ดของแบบฟอร์มแรกกัน โดยที่เราเรียกแบบฟอร์มที่สองและเปลี่ยนเป็นโค้ดต่อไปนี้:

โมฆะส่วนตัว button1_Click (ผู้ส่งวัตถุ EventArgs e) ( Form2 newForm = new Form2 (นี้); newForm.Show (); )

เนื่องจากในกรณีนี้ คำหลักนี้แสดงถึงการอ้างอิงถึงวัตถุปัจจุบัน - วัตถุ Form1 จากนั้นเมื่อสร้างแบบฟอร์มที่สอง จะได้รับ (ลิงก์) และควบคุมแบบฟอร์มแรกผ่านมัน

ตอนนี้หลังจากคลิกปุ่มแล้ว แบบฟอร์มที่สองจะถูกสร้างขึ้นซึ่งจะเปลี่ยนสีของแบบฟอร์มแรกทันที

เรายังสามารถสร้างวัตถุในรูปแบบปัจจุบัน:

โมฆะส่วนตัว button1_Click (ผู้ส่งวัตถุ EventArgs e) ( Form1 newForm1 = new Form1(); newForm1.Show(); Form2 newForm2 = new Form2(newForm1); newForm2.Show(); )

เมื่อทำงานกับหลายรูปแบบ คุณต้องคำนึงว่าหนึ่งในนั้นคือรูปแบบหลัก - ซึ่งเปิดตัวก่อนในไฟล์ Program.cs หากเราเปิดแบบฟอร์มหลายชุดพร้อมกัน เมื่อเราปิดแบบฟอร์มหลัก แอปพลิเคชันทั้งหมดจะปิดลงและปิดแบบฟอร์มอื่นๆ ทั้งหมดไปด้วย

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

วิธีที่ 1. การส่งผ่านการอ้างอิงไปยังตัวแปรสาธารณะ

Namespace WindowsApplication1 (คลาสสาธารณะบางส่วน Form1: ฟอร์ม (สาธารณะ Form1() ( InitializeComponent(); ) โมฆะส่วนตัว button1_Click (ผู้ส่งวัตถุ EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // ส่ง ลิงค์ไปยังปุ่มในรูปแบบ Form2 frm.ShowDialog( ) ) )

ใน Form2 ตัวแปรที่ลิงก์ถูกส่งผ่านจะสอดคล้องกับปุ่ม 1 จาก Form1

Namespace WindowsApplication1 ( คลาสสาธารณะบางส่วน Form2: ฟอร์ม ( ปุ่มสาธารณะ but1; // ตัวแปรนี้จะมีลิงก์ไปยังปุ่ม 1 จากฟอร์มสาธารณะ Form1() ( InitializeComponent(); ) โมฆะส่วนตัว button1_Click(ผู้ส่งวัตถุ, EventArgs e) ( but1. ข้อความ = "test"; // เปลี่ยนข้อความบนปุ่ม button1 ของ Form1 ) ) )

วิธีที่ 2. การส่งลิงก์ไปยังแบบฟอร์มลูก

สาระสำคัญจะใกล้เคียงกันในวิธีที่ 1 เมื่อเปิด Form2 เราจะส่งลิงก์ไปยังองค์ประกอบที่เราวางแผนจะเปลี่ยนแปลงในภายหลังเข้าไป

Namespace WindowsApplication1 ( คลาสสาธารณะบางส่วน Form1: ฟอร์ม ( public Form1() ( InitializeComponent(); ) โมฆะส่วนตัว button1_Click(ผู้ส่งวัตถุ, EventArgs e) ( Form2 frm = new Form2(this.button1); // ส่งลิงก์ไปยังปุ่ม ในรูปแบบ Form2 frm.ShowDialog( ) ) )

ตอนนี้ใน Form2 เราจำเป็นต้องสร้างตัวแปรที่จะมีลิงก์ไปยังปุ่มนี้ และเราจะเข้าถึงปุ่มบน Form1 (บรรทัดที่ 5,7,9 และ 15) ผ่านตัวแปรนั้น

Namespace WindowsApplication1 ( สาธารณะบางส่วนคลาส Form2: แบบฟอร์ม ( ปุ่มส่วนตัว but1; // ตัวแปรนี้จะมีลิงก์ไปยังปุ่ม button1 จากแบบฟอร์ม Form1 สาธารณะ Form2(ปุ่ม แต่) // รับลิงก์ไปยังปุ่มในตัวแปร แต่ ( but1 = แต่; // ตอนนี้ but1 จะเป็นลิงก์ไปยังปุ่ม button1 InitializeComponent(); ) โมฆะส่วนตัว button1_Click(objer sender, EventArgs e) ( but1.Text = "test"; // เปลี่ยนข้อความบนปุ่ม button1 ของ Form1 ) ) )

วิธีที่ 3. เข้าถึงแบบฟอร์มผู้ปกครองทั้งหมด

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

ขั้นตอนที่ 1.ในไฟล์ โปรแกรม.csสร้างตัวแปรสาธารณะ f1 (บรรทัดที่ 5)

Namespace WindowsApplication1 ( โปรแกรมคลาสคงที่ ( public static Form1 f1; // ตัวแปรที่จะมีลิงก์ไปยังฟอร์ม Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1( ) ) ) ) )

ขั้นตอนที่ 2.กำลังเปิด Form1.Designer.csและในนั้นสำหรับองค์ประกอบที่ต้องเข้าถึงจากรูปแบบอื่นเราเปลี่ยนแปลง ส่วนตัวบน สาธารณะ- ตัวอย่างเช่น เรามาทำให้ปุ่ม 1 บน Form1 พร้อมใช้งานสำหรับการเปลี่ยนแปลง

ระบบสาธารณะ Windows.Forms ปุ่มปุ่ม 1; // แทนที่ส่วนตัวด้วยสาธารณะ

ขั้นตอนที่ 3- เมื่อสร้าง Form1 เราจะกำหนดลิงก์ให้กับตัวแปร f1 ไปยังแบบฟอร์มนี้ (บรรทัดที่ 7)

Namespace WindowsApplication1 ( public คลาสบางส่วน Form1: Form ( public Form1() ( Program.f1 = this; // ตอนนี้ f1 จะเป็นลิงค์ไปยังฟอร์ม Form1 InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = ใหม่ Form2(); frm.ShowDialog();

ขั้นตอนที่ 4ตอนนี้จากทุกรูปแบบหรือจากคลาสใด ๆ คุณสามารถเข้าถึงองค์ประกอบ button1 ที่อยู่บน Form1 ได้ดังนี้: Program.f1.button1 ตัวอย่างเช่น ให้ปุ่มบน Form2 เปลี่ยนข้อความปุ่มบน Form1:

Namespace WindowsApplication1 ( สาธารณะบางส่วนคลาส Form2: แบบฟอร์ม (สาธารณะ Form2() ( InitializeComponent(); ) โมฆะส่วนตัว button1_Click(ผู้ส่งวัตถุ EventArgs e) ( Program.f1.button1.Text = "test"; // เปลี่ยนข้อความบน ปุ่มแบบฟอร์ม Form1 ) ) )