set child winform properties from a parent form when using simple injector c#

Question

I have a form1 (not mdi) which displays dialog on button click event, dialog basically is a pop up form which shows data on datagridview control.

I am using simple injector.

PopUpForm has a property called LocationData which is a datatable. I need to set that property in form1 (parent) so that data can be displayed on the PopUpForm when it is displayed on the screen.

Sorry, i am new to simple injector and still learning, any help or guidence would be appreciated. I even don't know if i am doing in a right way.

form1

On button click event

this._formOpener.ShowModalForm<PopUpForm>();

PopUpForm

public partial class PopUpForm : Form
{
    public DataTable LocationData { get; set; }

    public PopUpForm()
    {
        InitializeComponent();
    }

    private void PopUpForm_Load(object sender, EventArgs e)
    {
        dgvNearestLocations.DataSource = LocationData;

    }
}

program class

 static class Program
{
    private static Container container;

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Bootstrap();
        Application.Run(container.GetInstance<Form1>());
    }

    private static void Bootstrap()
    {
        // Create the container as usual.
        container = new Container();

        // Register your types, for instance:

        container.RegisterSingleton<IFormOpener, FormOpener>();
        container.Register<Form1>(Lifestyle.Singleton); ;
        container.Register<PopUpForm>(Lifestyle.Singleton); ;

        // Optionally verify the container.
        container.Verify();
    }

}

FormOpener

public class FormOpener : IFormOpener
{
    private readonly Container container;
    private readonly Dictionary<Type, Form> openedForms;

    public FormOpener(Container container)
    {
        this.container = container;
        this.openedForms = new Dictionary<Type, Form>();
    }

    public DialogResult ShowModalForm<TForm>() where TForm : Form
    {
        using (var form = this.GetForm<TForm>())
        {
            return form.ShowDialog();
        }
    }

    private Form GetForm<TForm>() where TForm : Form
    {
        return this.container.GetInstance<TForm>();
    }
}

Answer 1

First of all, you copied the FormOpener probably from this answer. But you missed the part about Forms needing to be transient. Don't register your forms as Singleton. Especially because you dispose them, this will work one and exactly one time. The next time you would want to show a Form you will get an ObjectDisposedException.

When you register the Forms as Transient Simple Injector will tell you that the forms implement IDisposable and this is (of course) correct. But because you take care of disposing in the FormOpener you can safely suppress this warning. Register your forms like this:

private static void RegisterWindowsForms(
      this Container container, IEnumerable<Assembly> assemblies)
{
    var formTypes =
        from assembly in assemblies
        from type in assembly.GetTypes()
        where type.IsSubclassOf(typeof(Form))
        where !type.IsAbstract
        select type;

    foreach (var type in formTypes)
    {
        var registration = Lifestyle.Transient.CreateRegistration(type, container);

        registration.SuppressDiagnosticWarning(DiagnosticType.DisposableTransientComponent,
            "Forms are disposed by application code. Letting Simple Injector do this " +
            "is problematic because that would need a scope, which is impossible to do.");

        container.AddRegistration(type, registration);
    }
}

To come to your question: What you need is some extra infrastructure to initialize the Form.

By letting your forms implement an interface IFormInit<T> you can pass data to the form and directly show it.

public interface IFormInit<T> : IDisposable
{
    DialogResult InitAndShowForm(T data);
}

To let Simple Injector create the forms based on this interface we need to register them in the container. We can let Simple Injector search for all closed implementations by supplying a list of assemblies, like this:

container.Register(typeof(IFormInit<>), assemblies, Lifestyle.Transient);

Notice that Simple Injector will automatically merge these registrations with the ones from RegisterWindowsForms. So you can now get an instance of Form by calling:

container.GetInstance<PopupForm>();
      or
container.GetInstance<IFormInit<SomeDataClass>>();   

You can now add this code to your FormOpener class:

public DialogResult ShowModalForm<TData>(TData data)
{
    Type formType = typeof(IFormInit<>).MakeGenericType(typeof(TData));
    dynamic initForm = this.container.GetInstance(formType);

    DialogResult result = (DialogResult) initForm.InitAndShowForm(data);

    initForm.Dispose();
    return result;
}

This will get the Form from the container based on the IFormInit<T> type that it implements. When you get the form, you call the function on the interface instead of directly call Form.ShowDialog(). When the form is closed you dispose of the Form.

Note: The use of dynamic typing maybe needs clarification. Why it is needed is inspired by the QueryHandler pattern described here.

Usage is as follows:

// Add a specific class to pass to the form
public class LocationDataWrapper
{
    public DataTable LocationData { get; set; }
}

public partial class PopUpForm : Form, IFormInit<LocationDataWrapper>
{
    public PopUpForm() => InitializeComponent();

    // Implement the interface, the loaded event can be removed
    public DialogResult InitAndShowForm(LocationDataWrapper data)
    {
        dgvNearestLocations.DataSource = data.LocationData;
        return this.ShowDialog();
    }
}

On button click event

DialogResult result = this._formOpener.ShowModalForm(new LocationDataWrapper
{
    LocationData = locationDataTable,
});

You can create wrapper or data classes for each form and it will automatically show the correct form, when you let this Form implement IFormInit<ThisSpecificDataClass>.