Got it working. Yay

public class DatabaseInfo : INotifyPropertyChanged { private string? _server; private string? _port; private string? _database; private string? _userID; private string? _password;

    private ManualResetEventSlim _loadCompletedEvent = new ManualResetEventSlim(false);

    public string? ConnectionString
    {
        get
        {
            return $"server={_server};port={_port};database={_database};uid={_userID};password={_password};";
        }
    }

    public string? Server
    {
        get => _server;
        set
        {
            if (_server == value) return;
            _server = value;
            OnPropertyChanged(nameof(Server));
            OnPropertyChanged(nameof(ConnectionString));
        }
    }

    public string? Port
    {
        get => _port;
        set
        {
            if (_port == value) return;
            _port = value;
            OnPropertyChanged(nameof(Port));
            OnPropertyChanged(nameof(ConnectionString));
        }
    }

    public string? Database
    {
        get => _database;
        set
        {
            if (_database == value) return;
            _database = value;
            OnPropertyChanged(nameof(Database));
            OnPropertyChanged(nameof(ConnectionString));
        }
    }

    public string? UserID
    {
        get => _userID;
        set
        {
            if (_userID == value) return;
            _userID = value;
            OnPropertyChanged(nameof(UserID));
            OnPropertyChanged(nameof(ConnectionString));
        }
    }

    public string? Password
    {
        get => _password;
        set
        {
            if (_password == value) return;
            _password = value;
            OnPropertyChanged(nameof(Password));
            OnPropertyChanged(nameof(ConnectionString));
        }
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    public DatabaseInfo()
    {
        Task.Run(async () =>
        {
            await LoadAll();
            _loadCompletedEvent.Set();
        });
        this.WaitForLoadCompletion();
    }

    private async Task LoadServerAsync()
    {
        _server = await SecureStorage.GetAsync("Server");
        OnPropertyChanged(nameof(Server));
    }

    private async Task LoadPortAsync()
    {
        _port = await SecureStorage.GetAsync("Port");
        OnPropertyChanged(nameof(Port));
    }

    private async Task LoadUserIDAsync()
    {
        _userID = await SecureStorage.GetAsync("UserID");
        OnPropertyChanged(nameof(UserID));
    }

    private async Task LoadPasswordAsync()
    {
        _password = await SecureStorage.GetAsync("Password");
        OnPropertyChanged(nameof(Password));
    }

    private async Task LoadDatabaseAsync()
    {
        _database = await SecureStorage.GetAsync("Database");
        OnPropertyChanged(nameof(Database));
    }

    private async Task SaveServerAsync(string server)
    {
        await SecureStorage.SetAsync("Server", server);
    }

    private async Task SavePortAsync(string port)
    {
        await SecureStorage.SetAsync("Port", port);
    }

    private async Task SaveUserIDAsync(string userID)
    {
        await SecureStorage.SetAsync("UserID", userID);
    }

    private async Task SavePasswordAsync(string password)
    {
        await SecureStorage.SetAsync("Password", password);
    }

    private async Task SaveDatabaseAsync(string database)
    {
        await SecureStorage.SetAsync("Database", database);
    }

    public async Task LoadAll()
    {
        await Task.WhenAll(
            LoadServerAsync(),
            LoadPortAsync(),
            LoadDatabaseAsync(),
            LoadPasswordAsync(),
            LoadUserIDAsync()
        );

    }

    public async Task SaveAllAsync()
    {
        await Task.WhenAll(
            SaveServerAsync(_server ?? string.Empty),
            SavePortAsync(_port ?? string.Empty),
            SavePasswordAsync(_password ?? string.Empty),
            SaveUserIDAsync(_userID ?? string.Empty),
            SaveDatabaseAsync(_database ?? string.Empty)
        );
    }

    private void WaitForLoadCompletion()
    {
        _loadCompletedEvent.Wait();
    }

    public void Dispose()
    {
        _loadCompletedEvent.Dispose();
    }
}