Several processing methods of communication between C # forms

In application development, it is often necessary to communicate data between multiple forms, write a few examples, and summarize several commonly used communication methods:

The main form Form1 is a ListBox, when you click to select a column, two controls pop up in the form Form2,form2, one is a textbox, the text of the selected column is displayed, the other is a button, the modified value is returned when clicked, and the text of the corresponding column is modified in Form1. The Form2 is closed at the same time.

Method One: Pass the value

First thought of, the Form2 constructor receives a string type argument, that is, the text of the selected row in Form1, sets the Form2 TextBox control's text to the string, which completes the Form1 to Form2. When the Form2 acceptchange button is pressed, you need to modify the value of the corresponding column in the listbox in the Form1, so you can consider that the ListBox control in the Form1 is also passed in Form2, all the modifications are done in Form2, according to this idea, The FORM2 code is as follows:

2. Publicpartial class Form2:form
4. {
6. private string text;
8. private ListBox lb;
10. private int index;
14. //constructor receives three parameters: Select row text, ListBox control, select Row index
16. Public Form2 (string text,listbox lb,int index)
18. {
20. this.text = text;
22. this.lb = lb;
24. This.index = index;
26. InitializeComponent ();
28. this.textBox1.Text = Text;
30. }
34. private void Btnchange_click (object sender, EventArgs e)
36. {
40. string text = This.textBox1.Text;
42. this.lb.Items.RemoveAt (index);
44. This.lb.Items.Insert (index, text);
46. This .  Close ();
48. }
50. }

Form1 in new Form 2 o'clock in this case:

2. Public partial class Form1:form
4. {
6. int index = 0;
8. string text = null;
10. Public Form1 ()
12. {
14. InitializeComponent ();
16. }
20. private void listbox1_selectedindexchanged (object sender, Eventargse)
22. {
24. if (this.listBox1.SelectedItem! = null)
26. {
28. Text = this.listBox1.SelectedItem.ToString ();
30. index = This.listBox1.SelectedIndex;
34. //Construction Form2 simultaneous transfer of parameters
36. Form2 Form2 = new Form2 (text, listBox1, index);
38. Form2. ShowDialog ();
40. }
42. }

OK, method One solution is this, the advantage is intuitive, what is needed to pass what, the shortcomings are also obvious, if the form 1 needs to modify the 100 control, is the structure of the time to pass 100 parameters in? Moreover, if other forms still need to play Form2, then the FORM2 will be discarded, only for use in Form 1, unless the overloaded constructor is written, not conducive to the reuse of code, continue to see the next method.

Method Two: Inherit this method I tried many times, inheritance can do, but trouble does not say, is not convenient, so personally think that if in order to manipulate the data and the use of inheritance, is not appropriate, but since it is a method, throw out to see, the actual role of ≈0. Form2:

2. Declaration Form2 inherited from Form1
6. public partial Classform2:form1
8. {
10. Publicint index;
14. Public ListBox lb;
16. Public Form2 (string text)
18. {
22. //Set inherited listbox to invisible
26. this.listbox1.visible=false;
28. InitializeComponent ();
30. this.textBox1.Text = Text;
32. }
34. private void Btnchange_click (object sender, EventArgs e)
36. {
38. string text = This.textBox1.Text;
40. this.lb.Items.RemoveAt (index);
42. This.lb.Items.Insert (Index,text);
44. This .  Close ();
48. }
50. }

Form1:

2. Public partial class Form1:form
4. {
6. public int index = 0;
8. public String text = null;
10. Public Form1 ()
12. {
14. InitializeComponent ();
16. }
20. private void listbox1_selectedindexchanged (object sender, Eventargse)
22. {
24. if (this.listBox1.SelectedItem! = null)
26. {
28. Text = this.listBox1.SelectedItem.ToString ();
30. index = This.listBox1.SelectedIndex;
32. Form2 Form2 = new Form2 (text);
36. //After constructing the Form2, assign values to the parameters in the Form2
38. form2.lb =This.listbox1;
40. Form2.index = index;
42. Form2. Show ();
44. }
46. }
48. }

Here are a few questions to note, which method of assignment is required for each attribute in Form2? From Java too much to know, Java inheritance in the subclass of the use of the keyword super can access the base class public methods and parameters, and C # in the super replaced by base, that means we can be in the FORM2 so that parameter assignment?

1. this.lb=Base.listbox1;
3. this.index=Base.index;

OK, the second way of writing no problem, you can save the index value, but to the ListBox control, so the assignment will be problematic, through the test I found that Base.listbox1 point, is the subclass inherits the ListBox1 object, not the base class own ListBox1 object. So we guessed that the Base.index value is also the index of the sub-class?   Test the discovery is true, so this.index=base.index is equal to not write, remove the same can be used, because the index is inherited by Form2, so we can understand that C # in the form of inheritance, through the base. Control cannot manipulate the base class control.   Method Three: Event callback since C # has an event this thing, why not, and the event in the form of communication, has a more convenient role, we know that the event is actually the capture of the state, in the end I will give an example of capturing state, first look at the example of data manipulation. Form2:

2. Defines a delegate that requires a string type argument
6. Publicdelegate void MyDelegate (string text);
10. Public partial class Form2:form1
12. {
16. //Define events for this delegate
18. public event MyDelegate MyEvent;
20. Public Form2 (string text)
22. {
24. InitializeComponent ();
26. this.textBox1.Text = Text;
28. }
30. private void Btnchange_click (object sender, EventArgs e)
32. {
36. //Trigger event and return the modified text
38. MyEvent (this.textBox1.Text);
40. This .  Close ();
42. }
44. }

Form1:

2. Public partial class Form1:form
4. {
6. public int index = 0;
8. public String text = null;
10. Public Form1 ()
12. {
14. InitializeComponent ();
16. }
20. private void listbox1_selectedindexchanged (object sender, Eventargse)
22. {
24. if (this.listBox1.SelectedItem! = null)
26. {
28. Text = this.listBox1.SelectedItem.ToString ();
30. index = This.listBox1.SelectedIndex;
32. Form2 Form2 = new Form2 (text);
36. //Register the MyEvent event for the Form2_myevent method
38. Form2.  MyEvent + = new MyDelegate (form2_myevent);
40. Form2. Show ();
42. }
44. }
48. //Processing
52. void Form2_myevent (string text)
54. {
56. this.listBox1.Items.RemoveAt (index);
58. This.listBox1.Items.Insert (index, text);
60. }
62. }

As you can see, it is convenient to use events, and there is no need to pass so many parameters, no inheritance, and improved code reuse, so it is recommended to do so under general requirements.

Several processing methods of communication between C # forms