[Пример для начинающих] Singel-form или навигация в WinForms через UserControl

internal class UIManager
{
    private Form? mainForm;
 
    public static UIManager Instance { get; } = new();
 
    private UIManager() { }
 
    public void RegMainForm(Form form)
        => mainForm = form;
 
    public void ShowAdminUserControl()
    {
        CheckRegMainForm();
        DropOld();
        var controls = mainForm!.Controls;
        controls.Add(new AdminUserControl
        { 
            Dock = DockStyle.Fill
        });
    }
    public void ShowClientUserControl()
    {
        CheckRegMainForm();
        DropOld();
        var controls = mainForm!.Controls;
        controls.Add(new ClientUserControl
        {
            Dock = DockStyle.Fill
        });
    }
 
    private void DropOld()
    {
        var controls = mainForm!.Controls;
        var olds = controls.Cast<Control>().ToArray();
        controls.Clear();
        foreach (Control control in olds)
            control.Dispose();
    }
    private void CheckRegMainForm()
    {
        if (mainForm is null)
            throw new Exception("main form not registration");
    }
}

ApplicationConfiguration.Initialize();
var mainForm = new MainForm();
UIManager.Instance.RegMainForm(mainForm);
Application.Run(mainForm);

public partial class AdminUserControl : UserControl
{
    public AdminUserControl() { InitializeComponent(); }
 
    private void ButtonClick(object sender, EventArgs e)
        => UIManager.Instance.ShowClientUserControl();
}
 
public partial class ClientUserControl : UserControl
{
    public ClientUserControl() { InitializeComponent(); }
 
    private void ButtonClick(object sender, EventArgs e)
        => UIManager.Instance.ShowAdminUserControl();
}

internal interface IViewUserControl
{
    public string? Title { get; }
    public bool Closing();
    public bool Close();
}

internal class MainForm : Form
{
    private Control? viewControl;
 
    public Control? View
    {
        get => viewControl;
        set
        {
            viewControl = value;
            Controls.Remove(viewControl);
            Controls.Add(value);
        }
    }
 
    protected override void OnClosing(CancelEventArgs e)
    {
        base.OnClosing(e);
        if (viewControl is IViewUserControl view)
            e.Cancel = !(view.Closing() && view.Close());
    }
}

internal record User(int Id, string Login);
 
internal class UserContext
{
    public User? CurrentUser { get; set; }
    public UserContext() { }
}

internal record UserData(int Id, string Login, string Password);
 
internal record DataItem(
    int Id,
    string Title,
    DateTime Date,
    string Text,
    byte[]? Image,
    UserData Author);
 
internal class DataService
{
    private static readonly UserData[] _usersMock;
    private static readonly List<DataItem> _dataMock;
    private readonly UserContext _userContext;
 
    private int AuthorId => _userContext.CurrentUser!.Id;
 
    static DataService()
    {
        var index = 1;
        var admin = new UserData(index++, "admin", "Nya!");
        var client = new UserData(index++, "client", "123");
        _usersMock = [admin, client];
 
        index = 0;
        _dataMock =
        [
            new DataItem(index++,
                "Hatsune Miku (初音ミク)",
                new DateTime(2007, 8, 31),
                @"Hatsune Miku (Japanese: 初音ミク), also...",
                null,
                admin),
            new DataItem(index++,
                "Kagamine Rin (鏡音リン)",
                new DateTime(2007, 12, 27),
                @"Kagamine Rin(Japanese: 鏡音リン), officially...",
                null,
                client),
            new DataItem(index++,
                "Kagamine Len (鏡音レン)",
                new DateTime(2007, 12, 27),
                @"Kagamine Len(Japanese: 鏡音リン), officially...",
                null,
                client),
            new DataItem(index++,
                "Megurine Luka (巡音ルカ)",
                new DateTime(2009, 1, 30),
                @"Megurine Luka (巡音ルカ, Megurine Ruka), codenamed CV03...",
                null,
                admin)
        ];
    }
    public DataService(UserContext userContext)
    {
        _userContext = userContext;
    }
 
    public User? SignIn(string login, string password)
    {
        var user = _usersMock
            .FirstOrDefault(x => 
                x.Login.Equals(login, StringComparison.OrdinalIgnoreCase)
                && x.Password == password);
        return user is null
            ? default
            : new User(user.Id, user.Login);
    }
    public IEnumerable<DataItem> LoadData(string filter)
    {
        var query = _dataMock.Where(x => x.Author.Id == AuthorId);
        if (!string.IsNullOrWhiteSpace(filter))
            query = query.Where(x => x.Title.Contains(filter)
                                  || x.Text.Contains(filter));
        return query.ToArray();
    }
    public DataItem SaveData(int? id, string title, DateTime date, string text, byte[]? image)
    {
        var author = _usersMock.First(x => x.Id == AuthorId);
        if (id.HasValue)
        {
            var index = _dataMock.FindIndex(x => x.Id == id);
            return _dataMock[index] = new DataItem(id.Value, title, date, text, image, author);
        }
        else
        {
            var nextId = _dataMock.Max(x => x.Id) + 1;
            var dataItem = new DataItem(nextId, title, date, text, image, author);
            _dataMock.Add(dataItem);
            return dataItem;
        }
    }
    public void DeleteData(int id)
        => _dataMock.RemoveAll(x => x.Id == id && x.Author.Id == AuthorId);
}

internal class ImageService
{
    public byte[] Conversion(string path)
    {
        using var image = Image.FromFile(path);
        using var bitmap = new Bitmap(200, 200);
        using var graphic = Graphics.FromImage(bitmap);
 
        int w = bitmap.Width, h = bitmap.Height, x = 0, y = 0;
 
        if (image.Width > image.Height)
        {
            var k = image.Height / (double)h;
            w = Convert.ToInt32(Math.Round(image.Width / k));
            x = -(w - bitmap.Width) / 2;
        }
        else
        {
            var k = image.Width / (double)w;
            h = Convert.ToInt32(Math.Round(image.Height / k));
            y = -(h - bitmap.Height) / 2;
        }
 
        graphic.DrawImage(image, x, y, w, h);
 
        using var memory = new MemoryStream();
        bitmap.Save(memory, ImageFormat.Jpeg);
        return memory.ToArray();
    }
}

internal partial class AuthUserControl : UserControl
{
    private readonly UserContext _userContext;
    private readonly DataService _dataService;
 
    public AuthUserControl(
        UserContext userContext,
        DataService dataService)
    {
        InitializeComponent();
        _userContext = userContext;
        _dataService = dataService;
    }
 
    private void SignInButtonClick(object sender, EventArgs e)
    {
        if (!IsValid())
            return;
 
        var login = loginTextBox.Text;
        var password = passwordTextBox.Text;
        var user = _dataService.SignIn(login, password);
        if (user == null)
        {
            errorLabel.Visible = true;
        }
        else
        {
            _userContext.CurrentUser = user;
            // TODO: on main
        }
    }
    private bool IsValid()
        => !string.IsNullOrEmpty(loginTextBox.Text)
        && !string.IsNullOrEmpty(passwordTextBox.Text);
}

internal partial class DataItemUserControl : UserControl
{
    private readonly DataItem _dataItem;
 
    public event Action<DataItemUserControl, DataItem>? OnDataDelete;
    public event Action<DataItemUserControl, DataItem>? OnDataEdit;
 
    public DataItemUserControl(DataItem dataItem)
    {
        InitializeComponent();
        _dataItem = dataItem;
        titleLabel.Text = dataItem.Title;
        dateLabel.Text = $"{dataItem.Date:dd MMMM yyyy}";
        richTextBox1.Text = dataItem.Text;
        this.SetImage(imagePictureBox, dataItem.Image);
    }
 
    private void EditButtonClick(object sender, EventArgs e)
        => OnDataEdit?.Invoke(this, _dataItem);
    private void DeleteButtonClick(object sender, EventArgs e)
    {
        if (this.ShowConfirmation("Delete item?"))
            OnDataDelete?.Invoke(this, _dataItem);
    }
}

internal partial class MainUserControl : UserControl, IViewUserControl
{
    private readonly UserContext _userContext;
    private readonly DataService _dataService;
 
    public string? Title => "client main section";
    private int WidhtDataItemControl => flowLayoutPanel.ClientSize.Width - 25;
 
    public MainUserControl(
        UserContext userContext,
        DataService dataService)
    {
        InitializeComponent();
        _userContext = userContext;
        _dataService = dataService;
        _uiNavigation = uiNavigation;
    }
 
    public bool Close() => true;
    public bool Closing() => true;
 
    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);
        userTitleLabel.Text = $"Hello, {_userContext.CurrentUser!.Login}!";
        LoadData();
    }
 
    private void SearchButtonClick(object sender, EventArgs e)
        => LoadData();
    private void AddButtonClick(object sender, EventArgs e)
    { /*TODO: on add*/ }
    private void OnDataEdit(DataItemUserControl _, DataItem dataItem)
    { /*TODO: on edit*/ }
    private void OnDataDelete(DataItemUserControl control, DataItem dataItem)
    {
        _dataService.DeleteData(dataItem.Id);
        flowLayoutPanel.Controls.Remove(control);
        control.Dispose();
    }
 
    private void LoadData()
    {
        var filter = filterTextBox.Text;
        Clear(flowLayoutPanel);
        var data = _dataService.LoadData(filter);
 
        var editMethod = OnDataEdit;
        var deleteMethod = OnDataDelete;
 
        foreach (var item in data)
        {
            var control = new DataItemUserControl(item)
            {
                Width = WidhtDataItemControl
            };
            control.OnDataEdit += editMethod;
            control.OnDataDelete += deleteMethod;
            flowLayoutPanel.Controls.Add(control);
            control.Disposed += (_, __) =>
            {
                control.OnDataEdit -= editMethod;
                control.OnDataDelete -= deleteMethod;
            };
        }
    }
    private void Clear(Control control)
    {
        var olds = new Control[control.Controls.Count];
        control.Controls.CopyTo(olds, 0);
        control.Controls.Clear();
        foreach (IDisposable child in olds)
            child.Dispose();
    }
}

internal partial class EditDataItemUserControl : UserControl, IViewUserControl
{
    private readonly DataService _dataService;
    private readonly ImageService _imageService;
    private DataItem? originalDataItem;
    private bool chageImage;
 
    public string? Title { get; }
 
    public EditDataItemUserControl(
        DataItem? dataItem, 
        DataService dataService,
        ImageService imageService)
    {
        InitializeComponent();
        _dataService = dataService;
        _imageService = imageService;
        SetData(dataItem);
        Title = dataItem is null
            ? "New record"
            : $"Edit record: {dataItem.Title}";
    }
 
    public bool Close() => true;
    public bool Closing()
    {
        if (HaveChanges())
        {
            if (originalDataItem == null && AllEmptry())
                return true;
 
            switch (this.ShowWarning("Save changes?"))
            {
                case DialogResult.Yes:
                    if (IsValid())
                    {
                        Save();
                        return true;
                    }
                    else
                    { 
                        this.ShowAlert("Title can't be emptry!", "not valid data", MessageBoxIcon.Warning);
                        return false;
                    }
                case DialogResult.No:
                    return true;
                default:
                    return false;
            }
        }
        return true;
    }
 
    protected override void OnSizeChanged(EventArgs e)
    {
        base.OnSizeChanged(e);
        this.AlignByCenter(centralPanel, backgroundImage);
    }
 
    private void EditPictureBoxClick(object sender, EventArgs e)
    {
        var dialog = new OpenFileDialog
        {
            Multiselect = false,
            Filter = "image|*.png;*.jpg;*.jpeg;*.bmp;*.gif;*.tif;*.tiff;*.webp"
        };
        if (dialog.ShowDialog(this) == DialogResult.OK)
        {
            try
            {
                var raw = _imageService.Conversion(dialog.FileName);
                this.SetImage(imagePictureBox, raw);
                chageImage = true;
            }
            catch
            {
                this.ShowError("Can't open image or parse image");
            }
        }
    }
    private void SaveButtonClick(object sender, EventArgs e)
    {
        if (IsValid())
            Save(true);
        else
            this.ShowAlert("Title can't be emptry!", "not valid data", MessageBoxIcon.Warning);
    }
    private void BackButtonClick(object sender, EventArgs e)
    { /*TODO: on main*/ }
 
    private void SetData(DataItem? dataItem)
    {
        originalDataItem = dataItem;
        titleTextBox.Text = dataItem?.Title ?? string.Empty;
        dateTimePicker.Value = dataItem?.Date ?? DateTime.Now;
        richTextBox.Text = dataItem?.Text ?? string.Empty;
        this.SetImage(imagePictureBox, dataItem?.Image);
    }
    private void Save(bool notifier = false)
    {
        var id = originalDataItem?.Id;
        var title = titleTextBox.Text;
        var text = richTextBox.Text;
        var date = dateTimePicker.Value;
        var image = (imagePictureBox.DataContext as MemoryStream)?.ToArray();
        originalDataItem = _dataService.SaveData(id, title, date, text, image);
        chageImage = false;
        if (notifier)
            this.ShowAlert("Completed");
    }
    private bool HaveChanges()
        => chageImage
        || originalDataItem is null
        || originalDataItem.Title != titleTextBox.Text
        || originalDataItem.Text != richTextBox.Text
        || originalDataItem.Date != dateTimePicker.Value;
    private bool IsValid()
        => !string.IsNullOrWhiteSpace(titleTextBox.Text);
    private bool AllEmptry()
        => string.IsNullOrWhiteSpace(titleTextBox.Text)
        && string.IsNullOrWhiteSpace(richTextBox.Text)
        && imagePictureBox.Image is null;
}

internal class UIFactory
{
    private readonly Lazy<UserContext> _globalUserContext;
    private readonly Lazy<DataService> _globalDataService;
    private readonly Lazy<MainForm> _mainForm;
 
    public UIFactory()
    {
        _globalUserContext = new(() => new());
        _globalDataService = new(() => new(_globalUserContext.Value));
        _mainForm = new(() =>
        {
            var mainForm = new MainForm
            {
                Size = new Size(1400, 720),
                StartPosition = FormStartPosition.CenterScreen,
                Icon = Resources.app
            };
            _globalUINavigation.Value.RegistrationMainForm(mainForm);
            return mainForm;
        });
    }
 
    public MainForm MainForm()
        => _mainForm.Value;
    public AuthUserControl AuthUserControl()
        => new(_globalUserContext.Value, _globalDataService.Valu);
    public MainUserControl MainUserControl()
        => new(_globalUserContext.Value, _globalDataService.Value);
    public EditDataItemUserControl EditUserControl(DataItem? dataItem)
        => new(dataItem, _globalDataService.Value, new());
}

internal class UINavigation(UIFactory uiFactory)
{
    private readonly UIFactory _uiFactory = uiFactory;
    private MainForm mainForm = default!;
 
    public void RegistrationMainForm(MainForm form)
        => mainForm = form;
    public void OnMain()
        => SwitchUserControl(_uiFactory.MainUserControl);
    public void OnAuthorization()
        => SwitchUserControl(_uiFactory.AuthUserControl);
    public void OnEdit(DataItem? dataItem = null)
        => SwitchUserControl(() => _uiFactory.EditUserControl(dataItem));
 
    private void CheckRegMainForm()
    {
        if (mainForm is null)
            throw new Exception("Main form not registration!");
    }
    private void SwitchUserControl(Func<UserControl> userControlFactory)
    {
        CheckRegMainForm();
        if (CloseCurrentUserControl())
        { 
            var userControl = userControlFactory();
            var old = mainForm.View;
            userControl.Dock = DockStyle.Fill;
            var delta = mainForm.Size - mainForm.ClientSize;
            mainForm.ClientSize = new Size(
                Math.Max(userControl.MinimumSize.Width, mainForm.ClientSize.Width),
                Math.Max(userControl.MinimumSize.Height, mainForm.ClientSize.Height));
            mainForm.MinimumSize = userControl.MinimumSize + delta;
            mainForm.Text = (userControl as IViewUserControl)?.Title ?? string.Empty;
            mainForm.View = userControl;
            old?.Dispose();
        }
    }
    private bool CloseCurrentUserControl()
        => mainForm.View is IViewUserControl view
            ? view.Closing() && view.Close()
            : true;
}

internal class UIFactory
{
    //... other fields
    private readonly Lazy<UINavigation> _globalUINavigation;
 
    public UIFactory()
    {
        //... 
        _globalUINavigation = new(() => new(this));
    }
 
    public UINavigation UINavigation()
        => _globalUINavigation.Value;
}

internal static class Program
{
    [STAThread]
    public static void Main()
    {
        ApplicationConfiguration.Initialize();
        var mainForm = Init();
        Application.Run(mainForm);
    }
 
    private static MainForm Init()
    {
        var factory = new UIFactory();
        var uiNavigation = factory.UINavigation();
        var mainForm = factory.MainForm();
        uiNavigation.OnAuthorization();
        return mainForm;
    }
}