C # several methods for communication between forms,

C # several methods for communication between forms,

During application development, data communication between multiple forms is often required. Write several examples to summarize several common communication methods:

 

 

The main form Form1 is a ListBox. When you click to select a column, two controls in the form Form2 and Form2 are displayed, one is TextBox, showing the text of the selected column and the other is a button, when you click the button, the modified value is returned, and the text of the corresponding column is modified in Form1, and Form2 is disabled.

 

Method 1: Pass the value

First, the Form2 constructor receives a string type parameter, that is, the Text of the row selected in Form1, and sets the Text of the TextBox Control of Form2 to this string, that is, the Form1 value is passed to Form2. When the Form2 AcceptChange button is pressed, you need to modify the value of the corresponding column in The ListBox in Form1. Therefore, you can also set the ListBox control in Form1 when the parameter is also passed to Form2, all modifications are completed in Form2. The Form2 code is as follows:

1. Publicpartial class Form2: Form
2. {
3. Private string text;
4. Private ListBox lb;
5. Private int index;
7. // The constructor receives three parameters: select the row text, ListBox control, and select the row index.
8. Public Form2 (string text, ListBox lb, int index)
9. {
10. This. text = text;
11. This. lb = lb;
12. This. index = index;
13. InitializeComponent ();
14. This. textBox1.Text = text;
15. }
17. Private void btnChange_Click (object sender, EventArgs e)
18. {
20. String text = this. textBox1.Text;
21. This. lb. Items. RemoveAt (index );
22. This. lb. Items. Insert (index, text );
23. This. Close ();
24. }
25. }

In Form1, new Form 2 is written as follows:

1. Public partial class Form1: Form
2. {
3. Int index = 0;
4. String text = null;
5. Public Form1 ()
6. {
7. InitializeComponent ();
8. }
10. Private void listBox1_SelectedIndexChanged (object sender, EventArgse)
11. {
12. If (this. listBox1.SelectedItem! = Null)
13. {
14. Text = this. listBox1.SelectedItem. ToString ();
15. Index = this. listBox1.SelectedIndex;
17. // Construct Form2 and pass parameters at the same time
18. Form2 form2 = new Form2 (text, listBox1, index );
19. Form2.ShowDialog ();
20. }
21. }

 

 

OK. The solution to method 1 is as follows. The advantage is that it is intuitive and the disadvantage is obvious. If Form 1 needs to modify one hundred controls, do we still need to input 100 parameters during the construction? Besides, if Form2 still needs to be played on other forms, Form2 will be discarded and can only be used in Form 1. Unless the overloaded constructor is written, it is not conducive to code reuse. continue to look at the next method.

Method 2: I have tried this method many times. inheritance can indeed be done, but it is not convenient. Therefore, I personally think that if inheritance is used to operate data on each other, it is not suitable, but since it is a method, let's take a look. The actual effect is ≈ 0. Form2:

1. // Declare that Form2 inherits from Form1
3. Public partial classForm2: Form1
4. {
5. Publicint index;
7. Public ListBox lb;
8. Public Form2 (string text)
9. {
11. // Set the inherited listBox to invisible
13. This. listBox1.Visible = false;
14. InitializeComponent ();
15. This. textBox1.Text = text;
16. }
17. Private void btnChange_Click (object sender, EventArgs e)
18. {
19. String text = this. textBox1.Text;
20. This. lb. Items. RemoveAt (index );
21. This. lb. Items. Insert (index, text );
22. This. Close ();
24. }
25. }

Form1:

1. Public partial class Form1: Form
2. {
3. Public int index = 0;
4. Public string text = null;
5. Public Form1 ()
6. {
7. InitializeComponent ();
8. }
10. Private void listBox1_SelectedIndexChanged (object sender, EventArgse)
11. {
12. If (this. listBox1.SelectedItem! = Null)
13. {
14. Text = this. listBox1.SelectedItem. ToString ();
15. Index = this. listBox1.SelectedIndex;
16. Form2 form2 = new Form2 (text );
18. // After Form2 is constructed, assign values to each parameter in Form2
19. Form2.lb = this. listBox1;
20. Form2.index = index;
21. Form2.Show ();
22. }
23. }
24. }

Which Assignment Method is required for each attribute in Form2? From Java, we all know that using the keyword super in the subclass of Java can access common methods and parameters in the base class, while in C #, super is replaced by base, does that mean we can assign a value to the parameter in Form2?

1. This. lb = base. listBox1;
3. This. index = base. index;

OK. There is no problem with the second method. You can save the index value, but for the ListBox control, this assignment will cause problems. Through testing, I found that base. listBox1 points to the listBox1 object inherited by the subclass, and is not the base class's own listBox1 object. So we guess, is the base. index value also pointing to the index of the subclass? The test shows that this is true, so this. index = base. if the index is not written, it can still be used. Because the index is inherited by Form2, we can understand that the form in C # inherits from base. the widget cannot operate the basic controls. Method 3: Event Callback since C # has an event, why not? Moreover, events play a more convenient role in form communication. We know that events are actually state capturing, at the end, I will give an example of the capture status. First, let's look at the examples of data operations. Form2:

1. // Define a delegate that requires a string-type parameter
3. Publicdelegate void MyDelegate (string text );
5. Public partial class Form2: Form1
6. {
8. // Define the delegate event
9. Public event MyDelegate MyEvent;
10. Public Form2 (string text)
11. {
12. InitializeComponent ();
13. This. textBox1.Text = text;
14. }
15. Private void btnChange_Click (object sender, EventArgs e)
16. {
18. // Trigger the event and send the modified text back
19. MyEvent (this. textBox1.Text );
20. This. Close ();
21. }
22. }

Form1:

1. Public partial class Form1: Form
2. {
3. Public int index = 0;
4. Public string text = null;
5. Public Form1 ()
6. {
7. InitializeComponent ();
8. }
10. Private void listBox1_SelectedIndexChanged (object sender, EventArgse)
11. {
12. If (this. listBox1.SelectedItem! = Null)
13. {
14. Text = this. listBox1.SelectedItem. ToString ();
15. Index = this. listBox1.SelectedIndex;
16. Form2 form2 = new Form2 (text );
18. // Register the MyEvent event of the form2_MyEvent Method
19. Form2.MyEvent + = new MyDelegate (form2_MyEvent );
20. Form2.Show ();
21. }
22. }
24. // Process
26. Void form2_MyEvent (string text)
27. {
28. This. listBox1.Items. RemoveAt (index );
29. This. listBox1.Items. Insert (index, text );
30. }
31. }

It can be seen that it is very convenient to use events, and there is no need to pass so many parameters, there is no inheritance relationship, and code reuse is improved. Therefore, under general requirements, we recommend that you use this method.