How can I pass Parameters to Form with this Generic Method?

I find this question very interesting, so I am going to try to give an option, although it may not be the ideal one.

The main problem is that there is no way to force a specific constructor in C#. That leaves us with one possible option (perhaps there are more).

My proposal is to create an Interface to create a method that allows receiving the parameters. This is an example:

public interface IFormulario
{
    void InicializarParametros(params object[] parametros);
}

Here we define a method, InicializarParametroswhich must be met by forms that implement this interface.

Later, in the forms that must be called from the generic form, we add the interface in its definition, and the mandatory method:

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

    public void InicializarParametros(params object[] parametros)
    {
        if (parametros.Length==2)
        {
            string parametro1 = parametros[0].ToString();
            int parametro2 = (int)parametros[1];
        }
        else
        {
            throw new Exception("El número de parámetros es incorrecto");
        }

    }       
}

Now we define the generic method to open the forms as follows:

private void AbrirFormulario<T>(params object[] args) where T : Form,IFormulario,  new()
{
    Form formulario;
    formulario = new T();
    ((IFormulario)formulario).InicializarParametros(args);
    formulario.Show();
}

Finally, the way to use it would be as follows:

AbrirFormulario<Form1>("a", 2);
AbrirFormulario<Form1>("a", 2, "b");
AbrirFormulario<Form1>();

Note that as I have defined the method InicializarParametros, examples 2 and 3 will throw an exception for an incorrect number of parameters. It is you who must control it in each case.

In the end I have decided to do it with Reflection (C#) . In that case, removing the restriction new()to allow forms without parameterless constructors:

public void AbrirFormulario<T>(params object[] args) where T : Form

Now, to create the instance, use Activator.CreateInstance:

T formulario = default(T);

if (args == null || args.Length == 0)
    formulario = Activator.CreateInstance<T>();
else
    formulario = (T)Activator.CreateInstance(typeof(T), args);

So the complete solution would look like this:

public void AbrirFormulario<T>(params object[] args) where T : Form
{
    Form formulario = panel_contenedor.Controls.OfType<T>().FirstOrDefault();
    if (formulario !=null)
    {
        //Si la instancia esta minimizada la dejamos en su estado normal
        if (formulario.WindowState == FormWindowState.Minimized)
        {
            formulario.WindowState = FormWindowState.Normal;
        }
        //Si la instancia existe la pongo en primer plano
        formulario.BringToFront();
        return;
    }
    //Se abre el form
    if (args == null || args.Length == 0)
        formulario = Activator.CreateInstance<T>();
    else
        formulario = (T)Activator.CreateInstance(typeof(T), args);
    formulario.TopLevel = false;
    panel_contenedor.Controls.Add(formulario);
    panel_contenedor.Tag = formulario;
    formulario.Show();
}

And to use it in these ways:

object[] args = new object[] { "a", true };

AbrirFormulario<Form1>(args);
AbrirFormulario<Form2>("b", 2, false);
AbrirFormulario<Form3>();

MSDN:

• Activator.CreateInstance Method

• Activator.CreateInstance Method (Type)

• Activator.CreateInstance Method (String, String)

Final solution:

Actually the best approach to do this is to use a factory method Func<T>to build the form:

Let's say we have this Form, just for testing purposes:

public class Form1 : Form
{
    public Form3(bool algunParametro, string algunTitulo)
    {

    }
}

With the method like this:

public void AbrirFormulario<T>(Func<T> metodofactory) where T : Form
{
      //Buscar el formulario dentro del panel.
      Form formulario = panel_contenedor.Controls.OfType<T>().FirstOrDefault();
      if (formulario != null)
      {
         //Si la instancia esta minimizada la dejamos en su estado normal
         if (formulario.WindowState == FormWindowState.Minimized)
         {
             formulario.WindowState = FormWindowState.Normal;
         }
         //Si la instancia existe la pongo en primer plano
         formulario.BringToFront();
         return;
     }

     //Se abre el form
     formulario = metodofactory();
     formulario.TopLevel = false;
     panel_contenedor.Controls.Add(formulario);
     panel_contenedor.Tag = formulario;
     formulario.Show();
}

Which is then called like this:

AbrirFormulario(() => new Form1(true, "Titulo"));
AbrirFormulario(() => new Form2());

Let's see how you can also leave out the <Form1>call part AbrirFormulario, it is inferred!

With all the helpful intellisense that goes with it:

So now we're left with self-documenting code, no matter how the form is built, and it's not forcing you to use an interface.

Problems usingparams object[] args :

There are now some useful self-documenting features about the constructor, namely that the parameters have names. And using something like this:

public void AbrirFormulario<T>(params object[] args) where T : Form
{
    //...
}

It gives the caller no information about what the "arguments" are, what order they belong to, or what they mean. So when we call it like this:

AbrirFormulario<Form1>(true, "Titulo");

The Intellisense doesn't help you because it only shows that you need to pass some (or no) parameter(s) to the method.

You could override the method and increase params for dynamic parameters.

    private void AbrirFormulario<T>() where T : Form, new()
    {
        AbrirFormulario<T>(null);
    }

    private void AbrirFormulario<T>(params object[] parametros) where T : Form, new()
    {
        Form formulario = panel_contenedor.Controls.OfType<T>().FirstOrDefault();
        if (formulario != null)
        {
            //Si la instancia esta minimizada la dejamos en su estado normal
            if (formulario.WindowState == FormWindowState.Minimized)
            {
                formulario.WindowState = FormWindowState.Normal;
            }
            //Si la instancia existe la pongo en primer plano
            formulario.BringToFront();
            return;
        }
        //Se abre el form
        formulario = new T();

        //Lógica para aplicar los parámetros, casteas a sus tipos correspondientes a como enviaste los parámetros.

        formulario.TopLevel = false;
        panel_contenedor.Controls.Add(formulario);
        panel_contenedor.Tag = formulario;
        formulario.Show();
    }

and its way of use

AbrirFormulario<Form>(5, false, 10); 
AbrirFormulario<Form>();