How to get the size of an inherited form in the base form?

Question

Suppose you have a form called FormBase and all other forms inherit from this form.
For example, I have public class Form formTest : FormBase

What I have now in the ctor of formTest:

public class Form formTest : FormBase
{
    public formTest()
    {
        InitializeComponent();
        Program.MainForm.AddToFormSizes(this, this.Size);
    }
}

This code adds the instance of formTest to a dictionary on the mainform with its size

This works, but I would like to move this code to FormBase so I don't have to put this line of code in every inherited form.

public class Form FormBase : Form
{
    public FormBase()
    {
        InitializeComponent();
        Program.MainForm.AddToFormSizes(this, this.Size);
    }
}

Now, the problem is that when I do that, size will have the size of FormBase in design-time, not the size of formTest.

Is there a way in FormBase to capture the size of formTest or any other form that inherited from FormBase?

for reference, this is the code of AddToFormSizes in the MainForm

private Dictionary<Form, Size> _formSizes = new Dictionary<Form, Size>();
public void AddToFormSizes(Form form, Size size)
{
    _formSizes.Add(form, form.Size);
}

I don't think there's anything you can do. The size of `formTest` is set (changed) in `formTest.InitializeComponent()` which `FormBase` knows nothing about. Before that happens, `formTest.Size` is the size derived from `FormBase`. — 41686d6564 stands w. Palestine, Apr 19 '19 at 08:34
Move this thing (does it compile?): `Program.MainForm.AddToFormSizes(this, this.Size);` to `protected override void OnHandleCreated(EventArgs e)`, after `base.OnHandleCreated(e);`. Inside your `base` Form. — Jimi, Apr 19 '19 at 08:54
@Jimi Good idea! That seems to work indeed. I stand corrected. — 41686d6564 stands w. Palestine, Apr 19 '19 at 08:59
@Jimi Yes that compiles. `MainForm` is just a static reference in `Program.cs` to acces my mainform. I will try this suggestion thank you — GuidoG, Apr 19 '19 at 09:00
BTW, you don't need a static reference of `MainForm` in `Program.cs`. You just need to make `AddToFormSizes()` static. You can call it from instance members inside `MainForm`. — Jimi, Apr 19 '19 at 09:15
@Jimi I need that reference for other things, not just for this method — GuidoG, Apr 19 '19 at 09:16
@Jimi Your approach works, if you write in as an answer I will accept it — GuidoG, Apr 19 '19 at 09:32

Jimi · Accepted Answer · 2020-06-06T16:59:29.547

Problem:
Using a Form as base for other Forms, in the base class constructor, the this reference returns the Size of the base class instead of the Size of the derived class.

public class FormBase : Form
{
    public FormBase()
    {
        InitializeComponent();
        Program.MainForm.AddToFormSizes(this, this.Size);
    }
}

It's just a matter of following the sequence of events:

FormDerived derived = new FormDerived()
=> FormBase.InitializeComponent()
=> FormDerived.InitializeComponent()
derived.Show()
=> FormBase.OnHandleCreated()

Given the constructor of a Form derived from FormBase:

public class FormDerived : FormBase
{
     public FormDerived() => InitializeComponents();    
}

when the class is first created:

FormDerived derived = new FormDerived();
derived.Show();

the constructor of the base class (FormBase) is called first.
At this point, the this reference is set to FormDerived, but all the properties, including the Name and the Form's Caption (Text), are set to the values of the base class.
Hence, calling a method that uses this in the base class constructor:

Program.MainForm.AddToFormSizes(this, this.Size);

this.Size will return the Size of the base class, not the derived class.

The FormDerived constructor is called next. At this point, all the properties defined in the InitializeComponent() method will be set.

If the AddToFormSizes() method is moved to the derived class constructor, this will reference the expected values. But, the static method call must be inserted in each derived class of FormBase.

The AddToFormSizes() method can be instead moved to and called from the overridden OnHandleCreated() method of the base class, which will be called when the derived Form is first shown:

derived.Show();

will cause a call to FormBase.OnHandleCreated().

At this point, the this reference is already set to the derived class and all the properties defined in InitializeComponent() will be already set to the values of the derived class.
Name, Text and Size included, of course.

Here, this is FormDerived with all the properties set in its constructor:

public class FormBase : Form
{
    public FormBase() => InitializeComponent();

    protected override void OnHandleCreated(EventArgs e)
    {
         base.OnHandleCreated(e);
         Program.MainForm.AddToFormSizes(this, this.Size);
    }
}

How to get the size of an inherited form in the base form?

1 Answers1

Linked