VB.NET - Dynamically Resize and Reposition All Controls when Form is Resized, Including Font Sizes

Public Class Form1

    Private mResizer As New Resizer
    Private mTick As DateTime

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load
        mResizer.FindAllControls(Me)
    End Sub

    Private Sub Form1_ResizeBegin(sender As Object, e As EventArgs) Handles Me.ResizeBegin
        mTick = Now
    End Sub

    Private Sub Form1_Resize(sender As Object, e As EventArgs) Handles Me.Resize
        Dim tickNow As DateTime = Now
        Dim delta As TimeSpan = tickNow - mTick
        If (delta.TotalMilliseconds > 125) Then
            mTick = tickNow
            mResizer.ResizeAllControls(Me)
        End If
    End Sub

    Private Sub Form1_ResizeEnd(sender As Object, e As EventArgs) Handles Me.ResizeEnd
        mResizer.ResizeAllControls(Me)
    End Sub

End Class

ctl.SetBounds(Int(parentWidth * c.leftOffsetPercent),
              Int(parentHeight * c.topOffsetPercent),
              Int(parentWidth * c.widthPercent),
              Int(parentHeight * c.heightPercent))

When the forms have many elements, downsizing is visible and it is a little annoying. To avoid this, I added a new optional parameter when I call ResizeAllControls function. This parameter is reported when called from the Resize event of the form, and is the same form. This is because in this case, I use the Opacity property, which hides the form while you are resizing. Modifications have they performed:
In the Form,:
Private Sub FrmUser_Resize(sender As Object, e As EventArgs) Handles Me.Resize
        rf.ResizeAllControls(Me, Me)
End Sub
In de Class, 
Public Sub ResizeAllControls(thisCtrl As Control, Optional wform As Form = Nothing)

        Dim fontRatioW As Single
        Dim fontRatioH As Single
        Dim fontRatio As Single
        Dim f As Font
        If IsNothing(wform) = False Then wform.Opacity = 0
……….
  Next '-- For Each
        If IsNothing(wform) = False Then wform.Opacity = 1
End Sub
I hope you find it useful.

ctl.Width = Int(parentWidth * c.widthPercent)
                            ctl.Height = Int(parentHeight * c.heightPercent)

If (ret) Then
                            '-- Size
                            ctl.Width = Int(parentWidth * c.widthPercent)
                            ctl.Height = Int(parentHeight * c.heightPercent)

                            '-- Position
                            ctl.Top = Int(parentHeight * c.topOffsetPercent)
                            ctl.Left = Int(parentWidth * c.leftOffsetPercent)

                            '-- Font
                            f = ctl.Font
                            fontRatioW = Int(parentWidth * c.widthPercent) / c.originalWidth
                            fontRatioH = Int(parentHeight * c.heightPercent) / c.originalHeight
                            fontRatio = (fontRatioW +
                            fontRatioH) / 2 '-- average change in control Height and Width
                            ctl.Font = New Font(f.FontFamily,
                            c.originalFontSize * fontRatio, f.Style)

                        End If

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Windows.Forms;

//-------------------------------------------------------------------------------
// Resizer
// This class is used to dynamically resize and reposition all controls on a form.
// Container controls are processed recursively so that all controls on the form
// are handled.
//
// Usage:
//  Resizing functionality requires only three lines of code on a form:
//
//  1. Create a form-level reference to the Resize class:
//     Resizer myResizer = new Resizer();
//
//  2. In the Form_Load event, call the  Resizer class FIndAllControls method:
//     myResizer.FindAllControls(this);
//
//  3. In the Form_Resize event, call the  Resizer class ResizeAllControls method:
//     myResizer.ResizeAllControls(this);
//
//-------------------------------------------------------------------------------

public class Resizer
{
    //----------------------------------------------------------
    // ControlInfo
    // Structure of original state of all processed controls
    //----------------------------------------------------------
    private struct ControlInfo
    {
        public string name;
        public string parentName;
        public double leftOffsetPercent;
        public double topOffsetPercent;
        public double heightPercent;
        public int originalHeight;
        public int originalWidth;
        public double widthPercent;
        public float originalFontSize;
    };

    //-------------------------------------------------------------------------
    // ctrlDict
    // Dictionary of (control name, control info) for all processed controls
    //-------------------------------------------------------------------------
    private Dictionary<string, ControlInfo> ctrlDict = new Dictionary<string, Resizer.ControlInfo>();

    //----------------------------------------------------------------------------------------
    // FindAllControls
    // Recursive function to process all controls contained in the initially passed
    // control container and store it in the Control dictionary
    //----------------------------------------------------------------------------------------
    public void FindAllControls(Control thisCtrl)
    {
        //-- If the current control has a parent, store all original relative position
        //-- and size information in the dictionary.
        //-- Recursively call FindAllControls for each control contained in the
        //-- current Control
        foreach (Control ctl in thisCtrl.Controls)
        {
            try
            {
                if (ctl.Parent != null)
                {
                    int parentHeight = ctl.Parent.Height;
                    int parentWidth = ctl.Parent.Width;

                    ControlInfo c = new ControlInfo();
                    c.name = ctl.Name;
                    c.parentName = ctl.Parent.Name;
                    c.topOffsetPercent = Convert.ToDouble(ctl.Top) / Convert.ToDouble(parentHeight);
                    c.leftOffsetPercent = Convert.ToDouble(ctl.Left) / Convert.ToDouble(parentWidth);
                    c.heightPercent = Convert.ToDouble(ctl.Height) / Convert.ToDouble(parentHeight);
                    c.widthPercent = Convert.ToDouble(ctl.Width) / Convert.ToDouble(parentWidth);
                    c.originalFontSize = ctl.Font.Size;
                    c.originalHeight = ctl.Height;
                    c.originalWidth = ctl.Width;
                    ctrlDict.Add(c.name, c);
                }
            }
            catch (Exception ex)
            {
                Debug.Print(ex.Message);
            }

            if (ctl.Controls.Count > 0)
            {
                FindAllControls(ctl);
            }
        }
    }

    //----------------------------------------------------------------------------------------
    // ResizeAllControls
    // Recursive function to resize and reposition all controls contained in the Control
    // dictionary
    //----------------------------------------------------------------------------------------
    public void ResizeAllControls(Control thisCtrl)
    {
        float fontRatioW, fontRatioH, fontRatio;
        Font f;

        //-- Resize and reposition all controls in the passed control
        foreach (Control ctl in thisCtrl.Controls)
        {
            try
            {
                if (ctl.Parent != null)
                {
                    int parentHeight = ctl.Parent.Height;
                    int parentWidth = ctl.Parent.Width;

                    ControlInfo c = new ControlInfo();
                    bool ret = false;
                    try
                    {
                        //-- Get the current control//s info from the control info dictionary
                        ret = ctrlDict.TryGetValue(ctl.Name, out c);

                        //-- If found, adjust the current control based on control relative
                        //-- size and position information stored in the dictionary
                        if (ret)
                        {
                            //-- Size
                            ctl.Width = (int)(parentWidth * c.widthPercent);
                            ctl.Height = (int)(parentHeight * c.heightPercent);

                            //-- Position
                            ctl.Top = (int)(parentHeight * c.topOffsetPercent);
                            ctl.Left = (int)(parentWidth * c.leftOffsetPercent);

                            //-- Font
                            f = ctl.Font;
                            fontRatioW = ctl.Width / c.originalWidth;
                            fontRatioH = ctl.Height / c.originalHeight;
                            fontRatio = (fontRatioW + fontRatioH) / 2;  //-- average change in control Height and Width
                            ctl.Font = new Font(f.FontFamily, c.originalFontSize * fontRatio, f.Style);
                        }
                    }
                    catch
                    {
                    }
                }
            }
            catch
            {
            }

            //-- Recursive call for controls contained in the current control
            if (ctl.Controls.Count > 0)
            {
                ResizeAllControls(ctl);
            }
        }
    }
}