Thực đơn
trang chủKỹ thuật

Cách mở một biểu mẫu mới trong c. Thêm biểu mẫu. Tương tác giữa các hình thức. Gọi phương thức biểu mẫu gốc từ biểu mẫu con

Câu hỏi được giải quyết trong bài viết này có nhiều khả năng liên quan đến chủ đề xây dựng kiến ​​trúc ứng dụng hơn là liên quan cụ thể đến vấn đề đang được xem xét. Việc chuyển dữ liệu từ dạng này sang dạng khác không khó chút nào. Để làm được điều này, chỉ cần mở điều khiển có dữ liệu mà chúng ta muốn lấy, tức là đánh dấu nó bằng công cụ sửa đổi công khai. Ngoài ra, một lựa chọn khác là có thể. Ví dụ: ở dạng đầu tiên, chúng ta tạo một đối tượng ở dạng thứ hai bằng cách chuyển một tham chiếu đến chính chúng ta tới hàm tạo, nghĩa là bằng cách chuyển một tham chiếu đến đối tượng thứ nhất từ ​​dạng thứ nhất sang dạng thứ hai
SecondForm SecondForm = new SecondForm(this);
Đương nhiên, trước khi thực hiện việc này, bạn nên chú ý đến việc tạo tình trạng quá tải cho hàm tạo của biểu mẫu thứ hai.

Và phương pháp này khá phổ biến. Tuy nhiên, với sự đơn giản của nó, nó tiềm ẩn nhiều vấn đề, trong đó nguyên nhân chính là vi phạm nguyên tắc đóng gói. Nói một cách dễ hiểu, hình thức thứ hai không được biết gì về sự tồn tại của hình thức thứ nhất và hơn thế nữa, không thể ảnh hưởng đến nó.

Giải pháp cho vấn đề này khá đơn giản. Hãy nhìn thẳng vào mã. Trong trình thiết kế, chúng ta tạo biểu mẫu chính (nó sẽ được khởi chạy khi ứng dụng khởi động). Hãy đặt một cái Hộp văn bản, Nhãn Và Cái nút.

Bằng cách nhấp vào nút, biểu mẫu thứ hai sẽ mở ra và văn bản từ trường văn bản của biểu mẫu chính sẽ được chuyển sang trường văn bản của biểu mẫu thứ hai. Ban đầu, hình thức thứ hai trông như thế này:

Tương tự như cái đầu tiên, nó có các điều khiển tương tự. Chúng tôi không cần nữa. Điểm vào ứng dụng khởi chạy biểu mẫu chính:

Sử dụng hệ thống; sử dụng System.Collections.Generic; sử dụng System.Linq; sử dụng System.Windows.Forms; không gian tên From1FormTo2 ( lớp tĩnh Program ( // Điểm vào chính cho ứng dụng. static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) ) )

Mã biểu mẫu chính trông như thế này:

Sử dụng hệ thống; sử dụng System.Collections.Generic; sử dụng System.ComponentModel; sử dụng System.Data; sử dụng System.draw; sử dụng System.Linq; sử dụng System.Text; sử dụng System.Windows.Forms; không gian tên From1FormTo2 ( public một phần lớp MainForm: Form ( //biểu mẫu thứ hai SecondForm SecondForm; //constructor public MainForm() ( Khởi tạoComponent(); ) // xử lý sự kiện truyền dữ liệu // từ biểu mẫu chính sang biểu mẫu riêng thứ hai void btn_mainForm_Click(object người gửi, EventArgs e) ( SecondForm = new SecondForm(tb_mainForm.Text.Trim()); twoForm.ShowDialog(); if (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = twoForm.ReturnData(); ) ) )

Theo đó, đừng quên kết nối nút với sự kiện Nhấp chuột. Ở đây trong lớp biểu mẫu chính có một trường Biểu mẫu thứ hai Biểu mẫu thứ hai, đại diện cho đối tượng biểu mẫu thứ hai. Khi bạn nhấp vào nút “Gửi”, một biểu mẫu thứ hai sẽ được tạo (hàm tạo quá tải được gọi, chúng tôi sẽ tạo nó sau) và khởi chạy bằng phương thức ShowDialog(). Trong trường hợp này, phương pháp này phù hợp với chúng tôi. Hơn nữa, sau đó, chúng tôi đảm bảo kiểm tra xem biểu mẫu thứ hai đã được đóng hay chưa nhưng đã nhấp vào nút của nó. Nếu một nút được nhấp vào biểu mẫu thứ hai thì biểu mẫu đầu tiên sẽ chấp nhận dữ liệu từ biểu mẫu thứ hai. Điều này xảy ra bằng cách gọi phương thức Trả về dữ liệu()ở dạng thứ hai.

Bây giờ phần thú vị nhất là mã ở dạng thứ hai:

Sử dụng hệ thống; sử dụng System.Collections.Generic; sử dụng System.ComponentModel; sử dụng System.Data; sử dụng System.draw; sử dụng System.Linq; sử dụng System.Text; sử dụng System.Windows.Forms; không gian tên From1FormTo2 ( public một phần class SecondForm: Form ( // hàm tạo quá tải public SecondForm(string data) ( Khởi tạoComponent(); tb_secondForm.Text = data; ) // xử lý sự kiện truyền dữ liệu // từ dạng thứ hai sang dạng chính void void btn_secondForm_Click (người gửi đối tượng, EventArgs e) ( this.DialogResult = DialogResult.OK; ) // phương thức công khai để truy cập // trường văn bản của biểu mẫu này chuỗi công khai ReturnData() ( return (tb_secondForm.Text.Trim()); ) ) )

Như bạn có thể thấy, có một hàm quá tải duy nhất chấp nhận một kiểu chuỗi. Hãy nhớ rằng chúng tôi đang cố gắng chuyển văn bản từ TextBox. Trong hàm tạo, các thành phần được lên lịch để khởi tạo và văn bản của trường văn bản được đặt thành giá trị được truyền từ biểu mẫu đầu tiên. Tiếp theo, bằng cách đăng ký sự kiện Nhấp chuộtđối với nút ở dạng thứ hai, chúng tôi đã tạo một trình xử lý btn_secondForm_Click, mô phỏng hoạt động của nút “Ok” của bất kỳ hộp thoại nào. Do đó, bằng cách nhấp vào nút “Gửi” (ở dạng thứ hai), chúng tôi thực hiện điều kiện

(thứ haiForm .DialogResult == DialogResult .OK)

Do đó, hình thức đầu tiên bằng cách gọi phương thức thứ haiForm .ReturnData(), chúng ta đặt trường văn bản của biểu mẫu thứ nhất thành giá trị của trường văn bản của biểu mẫu thứ hai.

Tôi nghĩ hoạt động của phương pháp này không cần phải giải thích nữa. Nó chỉ đơn giản trả về văn bản từ một trường văn bản duy nhất trong khi vẫn giữ nó ở chế độ riêng tư.

Kết quả là chúng tôi đã chuyển dữ liệu sang dạng thứ hai từ dạng thứ nhất và từ dạng thứ hai sang dạng thứ nhất mà không vi phạm nguyên tắc đóng gói.

Hãy thử nhập văn bản “aaa” vào trường văn bản của biểu mẫu đầu tiên và nhấp vào nút. Bạn sẽ thấy văn bản này trong trường văn bản ở dạng thứ hai mở ra. Hãy thử thay đổi văn bản thành “aaa ppp” và nhấp vào nút. Bạn sẽ thấy sau khi đóng biểu mẫu thứ hai, văn bản này sẽ xuất hiện như thế nào trong trường văn bản của biểu mẫu chính.

Bây giờ, tôi nghĩ bạn sẽ có thể chuyển dữ liệu giữa các biểu mẫu một cách chính xác hơn. Trong bài viết tiếp theo chúng ta sẽ nói về cách thực hiện điều đó trong các ứng dụng ASP.NET.

Đôi khi cần truy cập các phần tử của dạng này từ dạng khác trong quá trình thực hiện chương trình. Ví dụ: có một biểu mẫu Form1, từ đó chúng ta mở một Form2 khác và bây giờ, khi làm việc trong Form2, chúng ta cần truy cập các phần tử của biểu mẫu mẹ Form1. Tôi đã tìm thấy một số cách để làm điều này.

Phương pháp thứ 1. Truyền một tham chiếu đến một biến công khai.

Không gian tên WindowsApplication1 ( public một phần lớp Form1: Form ( public Form1() ( Khởi tạoComponent(); ) riêng void nút1_Click(đối tượng người gửi, EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // gửi liên kết tới nút ở dạng Form2 frm.ShowDialog(); ) ) )

Trong Form2, biến mà liên kết được chuyển đến bây giờ sẽ tương ứng với nút1 từ Form1

Không gian tên WindowsApplication1 ( public một phần lớp Form2: Form ( public Button but1; // biến này sẽ chứa một liên kết đến nút1 từ Form1 public Form2() ( Khởi tạoComponent(); ) riêng void nút1_Click(object sender, EventArgs e) ( but1. Text = "test"; // thay đổi văn bản trên nút nút1 của Form1 ) ) )

Phương pháp thứ 2. Truyền liên kết tới biểu mẫu con.

Bản chất gần giống nhau ở phương pháp thứ nhất. Khi mở Form2, chúng tôi chuyển vào đó một liên kết đến phần tử mà chúng tôi dự định thay đổi sau này.

Không gian tên WindowsApplication1 ( public một phần lớp Form1: Form ( public Form1() ( Khởi tạoComponent(); ) riêng void nút1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(this.button1); // chuyển một liên kết đến nút sang dạng Form2 frm.ShowDialog(); ) ) )

Bây giờ trong Form2 chúng ta cần tạo một biến sẽ chứa liên kết đến nút này và thông qua đó chúng ta sẽ truy cập vào nút trên Form1 (dòng 5,7,9 và 15).

Không gian tên WindowsApplication1 ( public một phần lớp Form2: Form ( Private Button but1; // biến này sẽ chứa liên kết đến nút Button1 từ dạng Form1 public Form2(Button but) // lấy liên kết đến nút trong biến nhưng ( but1 = but; // bây giờ but1 sẽ là liên kết đến nút Button1 LaunchizeComponent(); ) Private void Button1_Click(object sender, EventArgs e) ( but1.Text = "test"; // thay đổi văn bản trên nút Button1 của Form1 ) ) )

Phương pháp thứ 3. Truy cập vào toàn bộ biểu mẫu gốc.

Để thực hiện việc này, bạn cần thực hiện các thay đổi trong một số tệp, nhưng đồng thời chúng ta sẽ có quyền truy cập vào tất cả các thành phần của biểu mẫu gốc và không cần chuyển liên kết đến từng thành phần, như trong phương pháp 1.

Bước 1. Trong tập tin Chương trình.cs tạo một biến công khai f1 (dòng 5).

Không gian tên WindowsApplication1 ( lớp tĩnh Chương trình ( public static Form1 f1; // biến sẽ chứa liên kết đến biểu mẫu Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1( ) ); ) ) )

Bước 2. Khai mạc Form1.Designer.cs và trong đó, đối với các phần tử cần được truy cập từ dạng khác, chúng tôi thay đổi riêng tư TRÊN công cộng. Ví dụ: hãy cung cấp nút1 trên Form1 để thực hiện các thay đổi.

Nút System.Windows.Forms.Button công cộng1; // thay thế riêng tư bằng công khai

Bước 3. Khi tạo Form1 ta gán biến f1 một link cho form này (dòng 7)

Không gian tên WindowsApplication1 ( public một phần lớp Form1: Form ( public Form1() ( Program.f1 = this; // bây giờ f1 sẽ là một liên kết đến biểu mẫu Form1 Khởi tạoComponent(); ) riêng void nút1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(); frm.ShowDialog(); ) ) )

Bước 4. Giờ đây, từ bất kỳ biểu mẫu nào hoặc từ bất kỳ lớp nào, bạn có thể truy cập phần tử nút1 nằm trên Biểu mẫu1 như thế này: Program.f1.button1. Ví dụ: để nút trên Form2 thay đổi văn bản nút trên Form1:

Không gian tên WindowsApplication1 ( public một phần lớp Form2: Form ( public Form2() ( LaunchizeComponent(); ) Private void Button1_Click(object sender, EventArgs e) ( Program.f1.button1.Text = "test"; // Thay đổi văn bản trên nút biểu mẫu Biểu mẫu1 ) ) )

Bởi quản trị viên.

Học C# chậm. nhưng nó vẫn tiếp tục một cách trung thực. Mới đây tôi
đã đưa ra ví dụ về cách mở một biểu mẫu khác từ một biểu mẫu trong Visual C#. Về nguyên tắc, mọi thứ đều đơn giản.

Hôm nay, nhiệm vụ sau đã xuất hiện: khởi chạy một biểu mẫu phương thức từ biểu mẫu chính của ứng dụng; khi đóng, biểu mẫu này phải chuyển một số dữ liệu (văn bản, giá trị thuộc tính, v.v.) tới các điều khiển trên biểu mẫu chính. Không thể giải quyết vấn đề này bằng phương pháp được mô tả trong bài trước về biểu mẫu, bởi vì trong trường hợp này, chúng ta chỉ cần tạo một đối tượng biểu mẫu mới với các giá trị mới cho tất cả các thuộc tính. May mắn thay, C# có một trình thu thập rác tuyệt vời... Nhưng vấn đề không phải là trình thu thập mà là làm thế nào để mở một biểu mẫu con trong C# và sau đó quay lại biểu mẫu chính từ nó?

Để bắt đầu, hãy đặt dữ liệu ban đầu (ban đầu).

Vì thế. Chúng tôi có mẫu đơn chính:

Biểu mẫu này cũng chứa một TextBox có tên TBDialog và một nút Button mà chúng ta nên nhấp vào:

  1. Chuyển giá trị của thuộc tính Văn bản từ TBDialog sang TBMain;
  2. Đóng fDialog;

Bây giờ chúng ta hãy xem xét toàn bộ quá trình theo thứ tự.

Đầu tiên, cần nhớ rằng theo mặc định, tất cả các thuộc tính, biến và phương thức trong C# đều được gán một công cụ sửa đổi riêng tư– do đó, để chuyển từ biểu mẫu thứ hai sang biểu mẫu điều khiển ở biểu mẫu thứ nhất, chúng ta cần đặt công cụ sửa đổi cho TBMain công cộng của riêng mình. Để thực hiện việc này, hãy chọn phần tử TBMain trong công cụ thiết kế biểu mẫu, đi tới cửa sổ thuộc tính và thay đổi giá trị thuộc tính sửa đổi Với riêng tư TRÊN công cộng

Bây giờ TBMain sẽ hiển thị trong các đối tượng khác. Tiếp tục nào. Để mở biểu mẫu ở chế độ modal, chúng ta cần sử dụng một trong hai tùy chọn cho phương thức ShowDialog():

DialogResult ShowDialog() ; public DialogResult ShowDialog(IWin32Window owner);

Trong trường hợp đầu tiên, phương thức hiển thị biểu mẫu dưới dạng hộp thoại phương thức với cửa sổ hiện hoạt được đặt làm chủ sở hữu và trong trường hợp thứ hai, chúng ta có thể chỉ định độc lập biểu mẫu nào sẽ trở thành chủ sở hữu cho cửa sổ phương thức của mình.

Ví dụ: hãy sử dụng phiên bản thứ hai của phương thức ShowDialog() và hiển thị biểu mẫu thứ hai một cách vừa phải. Để làm điều này, chúng tôi sẽ viết như sau:

Ở đây tôi đã sử dụng lại từ khóa cái này , trỏ đến đối tượng hiện tại, tức là đặt biểu mẫu chính làm chủ sở hữu ( fChính). Bây giờ chúng ta hãy chuyển trực tiếp sang giải quyết vấn đề của chúng ta và trả lời câu hỏi: làm thế nào để chuyển giá trị từ dạng này sang dạng khác? Mỗi điều khiển có một đặc tính nổi bật Người sở hữu – trỏ đến cha mẹ:

Bây giờ bạn có thể chạy dự án và đảm bảo rằng văn bản từ TextBox trên biểu mẫu con được chuyển hoàn hảo sang TextBox trên biểu mẫu đầu tiên. Để đề phòng, tôi sẽ đăng mã nguồn của dự án được thảo luận trong ví dụ.

Cập nhật lần cuối: 31/10/2015

Để thêm một biểu mẫu khác vào dự án, nhấp chuột phải vào tên dự án trong cửa sổ Solution Explorer và chọn Add->Windows Form...

Hãy đặt tên cho biểu mẫu mới, ví dụ: Form2.cs:

Vì vậy, chúng tôi đã thêm biểu mẫu thứ hai vào dự án của mình. Bây giờ hãy thử triển khai tương tác giữa hai biểu mẫu. Giả sử biểu mẫu đầu tiên sẽ gọi biểu mẫu thứ hai khi nút được nhấp vào. Trước tiên, hãy thêm một nút vào biểu mẫu đầu tiên, Form1 và nhấp đúp vào nút đó để chuyển đến tệp mã. Vì vậy, chúng ta sẽ được đưa đến trình xử lý sự kiện click của nút, được tạo theo mặc định sau khi nhấp đúp vào nút:

Nút void riêng tư1_Click(người gửi đối tượng, EventArgs e) ( )

Bây giờ hãy thêm mã để gọi biểu mẫu thứ hai vào đó. Biểu mẫu thứ hai của chúng tôi được gọi là Form2, vì vậy trước tiên chúng tôi tạo một đối tượng của lớp này và sau đó để hiển thị nó trên màn hình, chúng tôi gọi phương thức Show:

Nút void riêng tư1_Click(người gửi đối tượng, EventArgs e) ( Form2 newForm = new Form2(); newForm.Show(); )

Bây giờ chúng ta hãy làm ngược lại - để hình thức thứ hai ảnh hưởng đến hình thức thứ nhất. Trong khi dạng thứ hai không biết về sự tồn tại của dạng thứ nhất. Để khắc phục điều này, bạn cần bằng cách nào đó chuyển thông tin về biểu mẫu thứ nhất sang biểu mẫu thứ hai. Để làm điều này, chúng ta sẽ sử dụng việc chuyển một liên kết đến biểu mẫu trong hàm tạo.

Vì vậy, hãy chuyển sang biểu mẫu thứ hai và đi tới mã của nó - nhấp chuột phải vào biểu mẫu và chọn Xem mã. Hiện tại nó trống và chỉ chứa một hàm tạo. Vì C# hỗ trợ nạp chồng phương thức, nên chúng ta có thể tạo một số phương thức và hàm tạo với các tham số khác nhau và gọi một trong số chúng tùy theo tình huống. Vì vậy, hãy thay đổi tệp mã của dạng thứ hai thành như sau:

Sử dụng hệ thống; sử dụng System.Collections.Generic; sử dụng System.ComponentModel; sử dụng System.Data; sử dụng System.draw; sử dụng System.Linq; sử dụng System.Text; sử dụng System.Threading.Tasks; sử dụng System.Windows.Forms; không gian tên HelloApp ( public một phần lớp Form2: Form ( public Form2() ( Khởi tạoComponent(); ) public Form2(Form1 f) ( Khởi tạoComponent(); f.BackColor = Color.Yellow; ) ) )

Trên thực tế, chúng tôi vừa thêm một hàm tạo mới ở đây, public Form2(Form1 f) , trong đó chúng tôi lấy biểu mẫu đầu tiên và đặt nền của nó thành màu vàng. Bây giờ, hãy chuyển sang mã của biểu mẫu đầu tiên, nơi chúng tôi gọi là biểu mẫu thứ hai và thay đổi nó thành dạng sau:

Nút void riêng tư1_Click(người gửi đối tượng, EventArgs e) ( Form2 newForm = new Form2(this); newForm.Show(); )

Vì trong trường hợp này từ khóa this đại diện cho một tham chiếu đến đối tượng hiện tại - đối tượng Form1, nên khi tạo biểu mẫu thứ hai, nó sẽ nhận nó (liên kết) và điều khiển biểu mẫu đầu tiên thông qua nó.

Bây giờ, sau khi nhấp vào nút, biểu mẫu thứ hai sẽ được tạo, biểu mẫu này sẽ ngay lập tức thay đổi màu của biểu mẫu đầu tiên.

Chúng ta cũng có thể tạo các đối tượng có dạng hiện tại:

Nút void riêng tư1_Click(người gửi đối tượng, EventArgs e) ( Form1 newForm1 = new Form1(); newForm1.Show(); Form2 newForm2 = new Form2(newForm1); newForm2.Show(); )

Khi làm việc với một số biểu mẫu, bạn phải tính đến việc một trong số chúng là biểu mẫu chính - được khởi chạy đầu tiên trong tệp Program.cs. Nếu chúng ta mở nhiều biểu mẫu cùng lúc, thì khi chúng ta đóng biểu mẫu chính, toàn bộ ứng dụng sẽ đóng lại và cùng với đó là tất cả các biểu mẫu khác.

Mặc dù quan điểm của tôi về Visual Studio của Microsoft vẫn như cũ nhưng đôi khi bạn phải làm gì đó với nó. Trên thực tế, nếu chúng ta chấp nhận thực tế là chúng ta viết không phải bằng C++ mà bằng cái gọi là C++/CLI, thì việc làm việc với các thành phần hình ảnh quen thuộc sẽ không quá khác biệt so với các môi trường Borland tương tự. Nhưng nó có thể gây ra nhiều vấn đề khi so sánh với Builder.Hãy xem xét 3 tình huống điển hình khi làm việc với một ứng dụng chứa nhiều hơn một biểu mẫu. Môi trường ví dụ là Visual C++ 2010 Express miễn phí, giả định rằng biểu mẫu chính có tên mặc định là Form1.

Một ví dụ về xây dựng và gọi một biểu mẫu theo chương trình

Mã này có thể được thực thi, ví dụ: bằng cách nhấp vào nút ở biểu mẫu chính Form1.

Biểu mẫu^form2 = gcnew Biểu mẫu(); Nút^ nút2 = gcnew Nút(); nút2->Văn bản = L"OK"; nút2->Vị trí = Điểm(10,10); form2->Text = L"Cửa sổ của tôi"; form2->HelpButton = true; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; form2->StartPosition = FormStartPosition::CenterScreen; form2->Điều khiển->Thêm(button2); form2->ShowDialog();

Để thêm trình xử lý nhấp chuột cho nút nút2 được tạo theo chương trình, chỉ cần viết trước dòng mã cuối cùng:

Button2->Click += gcnew System::EventHandler(this, &Form1::button2_Click);

Trước khi phương thức form2->ShowDialog() hoặc form2->Show() được gọi;

Trong trường hợp này, mã xử lý nằm trong mô-đun hiện tại Form1.h:

Riêng tư: System::Void Button2_Click(System::Object^ sender, System::EventArgs^ e) ( MessageBox::Show("Here"); )

Gọi một biểu mẫu khác từ biểu mẫu chính

Trong menu chọn Project - Thêm thành phần mới - Form - tên Form2

Hãy thêm một toán tử

#include "Form2.h"

trước không gian tên đầu tiên trong Form1.h (nghĩa là ở đầu tệp).

Hãy đưa một con trỏ tới thể hiện của lớp trong phần chung của lớp Form1:

Mẫu2^F2;

Hãy thêm mã vào nơi chúng ta cần tạo và gọi biểu mẫu thứ hai:

F2=gcnewForm2(); F2->Hiển thị();

Để xóa biểu mẫu thứ hai theo chương trình, đoạn mã sau phù hợp:

Xóa F2;

Cần lưu ý rằng con trỏ chỉ lưu trữ địa chỉ của một dạng, dạng được tạo lần cuối. Nếu chúng ta tạo tuần tự một số biểu mẫu bằng mã này thì chỉ biểu mẫu cuối cùng sẽ bị xóa. Ngoài ra, hãy thử mảng hình dạng được mô tả bên dưới.

Hãy mô tả dữ liệu cần thiết trong lớp biểu mẫu Form1 (ở đây là tên và không gian tên của dự án Tabulator, nếu cần, hãy thay thế bằng tên của bạn):

Const tĩnh int MAX_FORMS = 100; //Số lượng biểu mẫu tối đa int FormCount; //Mảng đếm biểu mẫu ^F2; //Con trỏ tới một mảng các biểu mẫu

Sau đó, chúng tôi khởi tạo dữ liệu bằng sự kiện Tải của biểu mẫu chính:

MẫuĐếm=0; F2 = mảng gcnew (MAX_FORMS);

Sau đó chúng ta sẽ triển khai code để tạo form tiếp theo

Nếu(FormCount Trình diễn(); ) else MessageBox::Show("Quá nhiều biểu mẫu!");

và loại bỏ nó:

Nếu (FormCount) ( xóa F2; FormCount--; )

Nếu chúng ta muốn tạo các biểu mẫu con không riêng biệt mà bên trong biểu mẫu gốc thì trong thuộc tính của Form1, chúng ta cần chỉ ra rằng đó là “tổ tiên” (đặt thuộc tính IsMdiParent = true) và trước khi hiển thị biểu mẫu con bằng cách sử dụng Toán tử F2->Show(), đánh dấu nó là Form1 con:

F2->MdiParent = cái này;

Gọi phương thức biểu mẫu gốc từ biểu mẫu con

Chúng ta khó có thể làm gì nếu không sử dụng tệp .cpp, điều này không tệ - viết mã trong tệp .h thường phá vỡ hệ thống C chính xác :)

Hãy mô tả quá trình từng bước.

1) Có 2 form - Form1 và Form2, trên Form1 có Button (button1, sẽ mở form thứ 2) và Label (nhãn1, ở đây chúng ta sẽ thay đổi chữ). Trên Form2 - nút1, khi bấm vào, văn bản trong nhãn1 sẽ thay đổi.

2) Vì chúng ta cần có quyền truy cập từ biểu mẫu thứ nhất sang biểu mẫu thứ hai và từ biểu mẫu thứ hai đến biểu mẫu thứ nhất, vấn đề tham chiếu chéo sẽ phát sinh (khi Form1.h đề cập đến Form2.h, do đó, lại đề cập đến đến Form1.h) . Để tránh điều này, chúng tôi sẽ di chuyển mã của biểu mẫu đầu tiên (Form1), mã này sẽ có quyền truy cập vào biểu mẫu thứ hai (Form2), từ tệp .h sang tệp .cpp. Vì vậy, bạn cần tạo một tệp Form1.cpp.

3) Khai báo một phương thức Set công khai trong Form1.h để bạn có thể thay đổi văn bản của nhãn1 (mã có thể được viết ở cuối tệp, sau #pragma endzone):

Công khai: void Set(String^ text) ( label1->Text = text; )

4) Trong tệp Form2.h, chúng tôi bao gồm Form1.h (ở đầu):

#include "Form1.h"

và tạo một hàm tạo sẽ chấp nhận và lưu liên kết đến biểu mẫu đầu tiên để sử dụng tiếp:

Form2(Form1^ parent) ( Khởi tạoComponent(); parentForm = parent; ) //bạn có thể viết một liên kết ngay bên dưới: riêng tư: Form1^ parentForm;

5) Khi nhấp vào nút trong Form2, chúng ta sẽ gọi phương thức Set của biểu mẫu gốc:

Riêng tư: System::Void Button1_Click(System::Object^ sender, System::EventArgs^ e) ( parentForm->Set("xin chào từ form2"); parentForm->Show(); this->Hide(); )

6) Vẫn phải mở biểu mẫu thứ hai ở biểu mẫu đầu tiên. Để thực hiện việc này, chúng tôi di chuyển trình xử lý bấm nút từ Form1.h sang Form1.cpp và trong tệp .h, chúng tôi chỉ để lại phần khai báo của nó.