How to get a method on a main form to get executed on the main form whenever i do some action on a secondary form?

Question

I'm trying to update my data on a main form whenever I change some option in a secondary form.

Possible solution:

Make the method public on Form1 (the main form) like this:

public void updatedata()
{
//data update
}

And then call it on the secondary form:

Form1.updatedata()

This doesn't work and I believe it's because he is trying to update the Form2

I'm using partial classes, but I'm not very well versed on them.

public partial class Form1 : Form
{
  public Form1()
  {
  InitializeComponent();
  }
}

And the secondary one:

 public partial class formOpConfig : Form
{
   private Form1 Opener { get; set; }



    public formOpConfig(Form1 opener)
    { //initialize component
    }
}

Answer 1

I feel like surely there is a duplicate question to match this one. But I have been unable to find it.

Given the code you posted, your attempt probably would have worked had you used Opener.updatedata() instead of Form1.updatedata(). But that still would not have been the best solution.

Commenter John Saunders is correct, the right way to do this is to declare an event in formOpConfig, and then have Form1 subscribe to it. That looks more like this:

public partial class formOpConfig : Form
{
    public event EventHandler UpdateData;

    private void SomethingHappens()
    {
        // do stuff...
        OnUpdateData();
        // maybe do other stuff too...
    }

    private void OnUpdateData()
    {
        EventHandler handler = UpdateData;

        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }
}

The above declares an event, and raises that event (invokes the handlers) at the appropriate time (i.e. when SomethingHappens()).

public partial class Form1 : Form
{
    private void OpenConfigForm()
    {
        OpenConfigForm opConfig = new formOpConfig();

        opConfig.UpdateData += (sender, e) => updatedata();
    }

    // Note that this method is private...no one else should need to call it
    private void updatedata()
    {
        //data update
    }
}

Here, Form1 subscribes to the event when it creates the instance of formOpConfig (I am assuming Form1 is what creates that instance), and when its handler is invoked, it calls the updatedata() method you've already written.

In this way, the two classes remain decoupled; i.e. they are not actually dependent on each other, more than they need to be (in particular, the formOpConfig class doesn't need to know anything about Form1).

Answer 2

A good way to do this is to use an Event.

This allows you to decouple the forms because they do not even need a reference to each other; basically an event is a way for your second form to tell whoever might be listening (without having to exactly know who) that something of interest happened, and to give them some information about that interesting event that they can use.

The linked article will give you much more detail than the below, which is just a quick idea of how to do it; I would recommend working through the tutorial!

The mechanism by which this occurs is that anyone who wants to know about interesting events on Form2 has to subscribe to the corresponding event on Form2; then whenever Form2 wants to tell its listeners that something has happened, it invokes any event handlers that have been attached to the event.

Because an event can have multiple handlers, it's a really excellent way to keep components in your application decoupled.

Quick demo

(note: code below is off top of head so not tested, no error handling, etc.)

First of all, you need to declare a class that can be used to send the interesting data to listening parties. This class has to inherit from System.EventArgs

public class InterestingEventArgs:EventArgs
{
   public string AnInterestingFact {get;private set;}
   public InterestingEventArgs(string fact)
   {
     AnInterestingFact =fact;
   }
}

It doesn't matter where you declare this as long as it's visible to both Form1 and Form2.

Next, you have to declare an event on Form2, it needs to be public and should look like this:

public event EventHandler<InterestingEventArgs> SomethingInterestingHappened;

Now you need to decide when you are going to tell interested parties about this event. Let's suppose you have a button on Form2 and you want to raise the event when you click it. So in the Click handler for the button, you might have code like this:

public void btnRaiseEvent_Clicked(object sender, EventArgs e)
{
   var fact= txtFact.Text;
   var handler = SomethingInterestingHappened;
   if (handler!=null)
   {
      handler(this,new InterestingEventArgs(fact));
   }
}

and finally here is how the code might look from Form1 when you are launching Form2, let's say you click a button on Form1 to launch Form2:

public void btnShowForm2_Clicked(object sender, EventArgs e)
{
   var child = new Form2();
   child.SomethingInterestingHappened+=OnSomethingInterestingHappened;
   child.Show();
}

Finally you need to write an event handler on Form1 that will be called when the event is raised:

void OnSomethingInterestingHappened(object sender, InterestingEventArgs e)
{
   MessageBox.Show("Did you know? " + e.AnInterestingFact);
}

Answer 3

It looks like you have passed in a reference to a Form1 object in the constructor. Use it:

public partial class formOpConfig : Form
{
    private Form1 Opener { get; set; }

    public formOpConfig(Form1 opener)
    { 
        Opener = opener;
    }

    private void updateForm1()
    {
        Opener.updatedata();
    }
}

Form1 is a class, not an object. You can say Form1.updatedata() if you make updatedata() a static method of the Form1 class, but that is probably not compatible with the rest of your code.