Como siempre, tienes varias soluciones. Te apunto un par de las que yo uso, dependiendo del caso.
1- El Form que invoca mantiene una referencia del Form que recibe la llamada.
Como dice lalo_soft, el método debe ser público.
Supongamos que tienes dos forms, uno llamado "MainWindow" y otro llamado "Opciones". El método es de "MainWindow", y en un momento dado queremos que lo invoque el Form "Opciones".
En este caso, en el momento de la creación de "Opciones" le pasamos en el constructor la referencia del "MainWindows".
Por ejemplo, si creamos los dos Forms por separado, desde el método de creación hacemos:
MainWindow MW = new MainWindow();
Opciones OP = new Opciones(MW);
Evidentemente, en el constructor de "Opciones" deberemos incluir el parámetro de entrada y guardar la referencia en una variable. Imaginemos que lo guardamos en la variable "_mw"
Así, cada vez que queramos invocar el método, desde "Opciones" simplemente haremos:
_mw.ElMetodo(los parametros);
Por ejemplo (2): creamos la "MainWindow" y desde ahí el resto de Forms. En el inicio de este (evento "MainWindow_Load" o incluso en el constructor) crearemos la referencia de "Opciones" y los otros Forms, y le pasamos directamente la referencia del "MainWindow".
Sería:
private void MainWindow_Load(object sender, EventArgs e) {
Opciones op = new Opciones(this);
}
Desde "Opciones" la estrategia sería la misma: guardar en una variable la referencia de la "MainWindow" e invocarla de la misma forma.
2- El Form que invoca no mantiene la referencia.
Esta estrategia es una de las que más uso. En vez de implementar otras estrategias más complejas y elegantes, yo prefiero esta por su simplicidad y flexibilidad.
Me hago una clase pública y estática, que mantiene referencias (estáticas) a objetos que deben ser accedidos desde varios sitios. De esta forma, cada objeto (ya sea un Form o cualquier otro), puede siempre acceder a la propiedad adecuada de la clase estática, que le devolverá siempre la misma referencia, en este caso, el Form cuyo método queremos invocar.
Con un ejemplo se ve más claro. Esta es la clase estática:
static class Globales {
// -----------------------------------
private static MainWindow mw = null; // Ventana principal
public static MainWindow MW{
get { return mw; }
set { mw = value; }
}
// -----------------------------------
private static Opciones op = null; // Ventana de opciones
public static Opciones OP{
get { return op; }
set { op = value; }
}
// y otros objetos que me interesa mantener como accesibles en cualquier lugar
}
Ahora, desde el método Main() de la aplicación, voy creando las instancias y seteandolas en la clase global:
[STAThread]
static void Main() {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Opciones ooo = new Opciones();
Globales.OP = ooo;
MainWindow mmm = new MainWindow ();
Globales.MW = mmm;
// corremos la ventana ppal
Application.Run(mmm);
}
Y así, sin guardar la referencia, desde "Opciones" siempre podemos hacer:
Globales.MW.ElMetodo(los parametros);
Hay otras soluciones, pero supongo que con una de estas ya te vale.
Saludos.
