Логин пароль windows forms

1
2

ApplicationConfiguration.Initialize();
Application.Run(new MainForm());

1
2
3
4
5
6
7
8
9
10

ApplicationConfiguration.Initialize();
if (Auth())
    Application.Run(new MainForm());
 
static bool Auth()
{
    using var dialog = new AuthForm();
    dialog.ShowDialog();
    return dialog.DialogResult == DialogResult.OK;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public class AuthService
{
    private readonly DataService _dataService = new();
 
    public async Task<bool> Auth(string login, string password)
    {
        var user = await _dataService.SignInAsync(login, password);
        // for cases where we don't have an asynchronous authorization method
        //var user =  await Task.Run(() => _db.SignIn(login, password));
 
        var result = user != null;
        if (result)
        {
            UserContext.Instance.CurrentUser = user;
        }
        return result;
    }
}
 
public class UserContext
{
    public static UserContext Instance { get; } = new();
 
    public User? CurrentUser { get; set; }
 
    public bool IsAuthed => CurrentUser != null;
 
    private UserContext() { }
}
 
public record User(string Login);
 
public class DataService
{
    private readonly TimeSpan _delay = TimeSpan.FromSeconds(2);
 
    public User? SignIn(string login, string password)
    {
        Thread.Sleep(_delay);
        return CheckAndResult(login, password);
    }
 
    public async Task<User?> SignInAsync(string login, string password)
    {
        await Task.Delay(_delay);
        return CheckAndResult(login, password);
    }
 
    private User? CheckAndResult(string login, string password)
        => login == "admin" && password == "Nya!"
            ? new User(login)
            : default;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public partial class AuthForm : Form
{
    private readonly AuthService _authService;
 
    public AuthForm(AuthService authService)
    {
        InitializeComponent();
        _authService = authService;
        DialogResult = DialogResult.None; // если окно просто закрыть, то вернет не ОК, что приведет к закрытию всей программы.
    }
 
    private async void LoginButtonClick(object sender, EventArgs e)
        => await SignIn();
    private async void PasswordTextBoxKeyDown(object sender, KeyEventArgs e)
    {
        if (e.KeyCode == Keys.Enter)
            await SignIn();
    }
 
    private async Task SignIn()
    {
        var login = loginTextBox.Text;
        var password = passwordTextBox.Text;
        if (!(string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password)))
        {
            Enabled = false;
            var result = await _authService.Auth(login, password);
            Enabled = true;
            if (result)
            {
                DialogResult = DialogResult.OK;
                Close();
            }
            else
                MessageBox.Show(this, "неверный логин или пароль", null, MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public partial class AuthForm : Form
{
    private readonly AuthService _authService;
    private bool autoLogin;
 
    public AuthForm(AuthService authService, string? login, string? password, bool remember, bool auto)
    {
        InitializeComponent();
        _authService = authService;
        loginTextBox.Text = login;
        passwordTextBox.Text = password;
        rememberCheckBox.Checked = remember;
        autoLogin = auto;
    }
 
    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);
        if (autoLogin)
        {
            autoLogin = false;
            _ = SignIn();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class AuthService
{
    private readonly DataService _dataService = new();
 
    public async Task<bool> Auth(string login, string password, bool remember)
    {
        var user = await _dataService.SignInAsync(login, password);
        // for cases where we don't have an asynchronous authorization method
        //var user =  await Task.Run(() => _db.SignIn(login, password));
 
        var result = user != null;
        if (result)
        {
            UserContext.Instance.CurrentUser = user;
            if (remember)
            { 
                Settings.Default.Login = login;
                Settings.Default.Password = password;
                Settings.Default.Save();
            }
        }
        return result;
    }
 
    public (string Login, string Password)? LoadSecure()
    {
        var login = Settings.Default.Login;
        var password = Settings.Default.Password;
        if (!(string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password)))
            return (login, password);
        return default;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

static bool Auth(string[] args)
{
    var authService = new AuthService();
    string? login = default;
    string? password = default;
    bool remember = false;
    bool auto = false;
 
    var savedData = authService.LoadSecure();
    if (savedData is not null)
    {
        (login, password) = savedData.Value;
        auto = true;
    }
 
    using var dialog = new AuthForm(authService, login, password, remember, auto);
    dialog.ShowDialog();
    return UserContext.Instance.IsAuthed;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

static bool Auth(string[] args)
{
    var authService = new AuthService();
    string? login = default;
    string? password = default;
    bool remember = false;
    bool auto = false;
 
    if (args is [var _login, var _password, .. var r])
    {
        login = _login;
        password = _password;
        _ = bool.TryParse(r?.FirstOrDefault(), out remember);
        auto = true;
    }
    else 
    {
        var savedData = authService.LoadSecure();
        if (savedData is not null)
        {
            (login, password) = savedData.Value;
            auto = true;
        }
    }
 
    using var dialog = new AuthForm(authService, login, password, remember, auto);
    dialog.ShowDialog();
    return UserContext.Instance.IsAuthed;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

internal interface ISafeExecuteControl
{
    Control ContainerForLoading { get; }
    Control? LockControl { get; }
}
 
internal static class Helper
{
    public static async Task SafeUIExecuteAsync(
        this ISafeExecuteControl control,
        Func<Task> task,
        string errorMessage = "runtime error")
    {
        var parent = control.ContainerForLoading;
 
        if(control.LockControl is not null)
            control.LockControl.Enabled = false;
        using var loading = new LoadingControl
        {
            Anchor = AnchorStyles.None
        };
        var x = parent.ClientSize.Width / 2 - loading.Width / 2;
        var y = parent.ClientSize.Height / 2 - loading.Height / 2;
        loading.Location = new Point(x, y);
        parent.Controls.Add(loading);
        parent.Controls.SetChildIndex(loading, 0);
 
        try
        {
            await task();
        }
        catch
        {
            MessageBox.Show(parent, errorMessage, "error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
        finally
        {
            parent.Controls.Remove(loading);
            if (control.LockControl is not null)
                control.LockControl.Enabled = true;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public partial class AuthForm : Form, ISafeExecuteControl
{
    //.. другие поля
 
    public Control ContainerForLoading => this;
    public Control LockControl => containerPanel;
 
    //.. конструктор и прочее
 
    private async Task SignIn()
    {
        var login = loginTextBox.Text;
        var password = passwordTextBox.Text;
        var remember = rememberCheckBox.Checked;
        if (!(string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password)))
        {
            await this.SafeUIExecuteAsync(async () =>
            {
                if (await _authService.Auth(login, password, remember))
                    Close();
                else
                    MessageBox.Show(this, "неверный логин или пароль", null, MessageBoxButtons.OK, MessageBoxIcon.Error);
            },
            "Ошибка авторизации.");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

using Nya.AuthExample.Forms.UserControls;
using Nya.AuthExample.Services;
namespace Nya.AuthExample.UI.Forms;
 
public partial class MainForm : Form, ISafeExecuteControl
{
    private readonly DataService _dataService;
 
    public Control ContainerForLoading => this;
    public Control? LockControl => null;
 
    public MainForm()
    {
        InitializeComponent();
        _dataService = new();
    }
 
    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);
        _ = this.SafeUIExecuteAsync(LoadData, "Ошибка загрузки данных");
    }
 
    private async Task LoadData()
    {
        var data = await _dataService.Load();
 
        #region update view
 
        SuspendLayout();
 
        var width = ClientSize.Width - 45;
        foreach (var item in data)
        {
            var itemControl = new DataItemControl(item)
            {
                Width = width
            };
            dataFlowLayoutPanel.Resize += (_, a) =>
            {
                int w = dataFlowLayoutPanel.ClientSize.Width - 45;
                int h = itemControl.Size.Height;
                itemControl.Size = new Size(w, h);
            };
            dataFlowLayoutPanel.Controls.Add(itemControl);
        }
 
        ResumeLayout(false);
        PerformLayout();
 
        #endregion
    }
}