Delegates – Code Example

public class User
{
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }
    public string? EmailAddress { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Password { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string PhoneNumber { get; set; }
    public string AddressFirstLine { get; set; }
    public string AddressSecondtLine { get; set; }
    public string AddressCity { get; set; }
    public string PostCode { get; set; }
}

public class ClubMembershipDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite($"Data Source={AppDomain.CurrentDomain.BaseDirectory}ClubMembershipDb.db");
        base.OnConfiguring(optionsBuilder);
    }
}

public class ClubMembershipDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite($"Data Source={AppDomain.CurrentDomain.BaseDirectory}ClubMembershipDb.db");
        base.OnConfiguring(optionsBuilder);
    }

    public DbSet<User> Users { get; set; }
}

Add-Migration FirstCreate

update-database

// See that a field is not empty
public delegate bool RequiredValidDel(string fieldVal);
// Constrain a value of a field between min and max value
public delegate bool StringLengthValidDel(string fieldVal, int min, int max);
// Date validator
public delegate bool DateValidDel(string fieldVal, out DateTime validDateTime);
// Valid a field value compare to a regular expression
public delegate bool PattenMatchValidDel(string fieldVal, string pattern);
// Validate a text field compare to another text field
public delegate bool CompareFieldsValidDel(string fieldVal, string fieldValCompare);

public class CommonFieldValidatorFunctions
{
    private static RequiredValidDel _requiredValidDel = null;
    private static StringLengthValidDel _stringLengthValidDel = null;
    private static DateValidDel _dateValidDel = null;
    private static PattenMatchValidDel _pattenMatchValidDel = null;
    private static CompareFieldsValidDel _compareFieldsValidDel = null;
}

public class CommonFieldValidatorFunctions
{
    private static RequiredValidDel _requiredValidDel = null;
    private static StringLengthValidDel _stringLengthValidDel = null;
    private static DateValidDel _dateValidDel = null;
    private static PattenMatchValidDel _pattenMatchValidDel = null;
    private static CompareFieldsValidDel _compareFieldsValidDel = null;

    private static bool RequiredFieldValid(string fieldVal)
    {
        if (!string.IsNullOrEmpty(fieldVal))
            return true;
        return false;
    }

    private static bool StringFieldLengthValid(string fieldVal, int min, int max)
    {
        if (fieldVal.Length >= min && fieldVal.Length <= max)
            return true;
        return false;
    }

    private static bool DateFieldValid(string dateTime, out DateTime validDateTime)
    {
        if (DateTime.TryParse(dateTime, out validDateTime))
            return true;
        return false;
    }

    private static bool FieldPatternValid(string fieldVal, string regularExpressionPattern)
    {
        Regex regex = new Regex(regularExpressionPattern);

        if (regex.IsMatch(fieldVal))
            return true;
        return false;
    }

    private static bool FieldComparisonValid(string field1, string field2)
    {
        if (field1.Equals(field2))
            return true;
        return false;
    }
}

public class CommonFieldValidatorFunctions
{
    private static RequiredValidDel _requiredValidDel = null;
    ...

    public static RequiredValidDel RequiredFieldValidDel
    {
        get
        {
            if (_requiredValidDel == null)
                _requiredValidDel = new RequiredValidDel(RequiredFieldValid);
            return _requiredValidDel;
        }
    }

    public static StringLengthValidDel StringLengthFieldValid
    {
        get
        {
            if (_stringLengthValidDel == null)
                _stringLengthValidDel = new StringLengthValidDel(StringFieldLengthValid);
            return _stringLengthValidDel;
        }
    }

    public static DateValidDel DateFieldValidDel
    {
        get
        {
            if (_dateValidDel == null)
                _dateValidDel = new DateValidDel(DateFieldValid);
            return _dateValidDel;
        }
    }

    public static PattenMatchValidDel PattenMatchValidDel
    {
        get
        {
            if (_pattenMatchValidDel == null)
                _pattenMatchValidDel = new PattenMatchValidDel(FieldPatternValid);
            return _pattenMatchValidDel;
        }
    }

    public static CompareFieldsValidDel FieldsCompareValidDel
    {
        get
        {
            if (_compareFieldsValidDel == null)
                _compareFieldsValidDel = new CompareFieldsValidDel(FieldComparisonValid);
            return _compareFieldsValidDel;
        }
    }

    private static bool RequiredFieldValid(string fieldVal)
    {
        if (!string.IsNullOrEmpty(fieldVal))
            return true;
        return false;
    }

    ...
}

public static class CommonRegularExpressionValidationPatterns
{
    public const string Email_Address_RegEx_Pattern = @"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$";

    public const string Uk_PhoneNumber_RegEx_Pattern = @"^\(?(?:(?:0(?:0|11)\)?[\s-]?\(?|\+)44\)?[\s-]?\(?(?:0\)?[\s-]?\(?)?|0)(?:\d{2}\)?[\s-]?\d{4}[\s-]?\d{4}|\d{3}\)?[\s-]?\d{3}[\s-]?\d{3,4}|\d{4}\)?[\s-]?(?:\d{5}|\d{3}[\s-]?\d{3})|\d{5}\)?[\s-]?\d{4,5}|8(?:00[\s-]?11[\s-]?11|45[\s-]?46[\s-]?4\d))(?:(?:[\s-]?(?:x|ext\.?\s?|\#)\d+)?)$";

    public const string Uk_Post_Code_RegEx_Pattern = @"([Gg][Ii][Rr] 0[Aa]{2})|((([A-Za-z][0-9]{1,2})|(([A-Za-z][A-Ha-hJ-Yj-y][0-9]{1,2})|(([A-Za-z][0-9][A-Za-z])|([A-Za-z][A-Ha-hJ-Yj-y][0-9][A-Za-z]?))))\s?[0-9][A-Za-z]{2})";

    public const string Strong_Password_RegEx_Pattern = @"(?=^.{6,10}$)(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+}{":;'?/>.<,])(?!.*\s).*$";
}

public delegate bool FieldValidatorDel(int fieldIndex, string fieldValue, string[] fieldArray, out string fieldInvalidMessage);

public interface IFieldValidator
{
}

public delegate bool FieldValidatorDel(int fieldIndex, string fieldValue, string[] fieldArray, out string fieldInvalidMessage);
public interface IFieldValidator
{
    void InitialiseValidatorDelegates();
    string[] FieldArray { get; }
    FieldValidatorDel ValidatorDel { get; }
}

public class FieldConstants
{
    public enum UserRegistrationField
    {
        EmailAddress,
        FirstName,
        LastName,
        Password,
        PasswordCompare,
        DateOfBirth,
        PhoneNumber,
        AddressFirstLine,
        AddressSecondLine,
        AddressCity,
        PostCode
    }
}

public class UserRegistrationValidator : IFieldValidator
{
    const int FirstName_Min_Length = 2;
    const int FirstName_Max_Length = 100;
    const int LastName_Min_Length = 2;
    const int LastName_Max_Length = 100;

    // Check if the user email already exists in users table
    delegate bool EmailExistsDel(string emailAddress);
}

public class UserRegistrationValidator : IFieldValidator
{
    const int FirstName_Min_Length = 2;
    ...

    FieldValidatorDel _fieldValidatorDel = null;

    RequiredValidDel _requiredValidDel = null;
    StringLengthValidDel _stringLengthValidDel = null;
    DateValidDel _dateValidDel = null;
    PattenMatchValidDel _pattenMatchValidDel = null;
    CompareFieldsValidDel _compareFieldsValidDel = null;

    EmailExistsDel _emailExistsDel = null;
}

public class UserRegistrationValidator : IFieldValidator
{
    const int FirstName_Min_Length = 2;
    ...

    FieldValidatorDel _fieldValidatorDel = null;
    ...

    string[] _fieldArray = null;

    public string[] FieldArray
    {
        get
        {
            if (_fieldArray == null)
                _fieldArray = new string[Enum.GetValues(typeof(FieldConstants.UserRegistrationField)).Length];
            return _fieldArray;
        }
    }
}

public class UserRegistrationValidator : IFieldValidator
{
    const int FirstName_Min_Length = 2;
    ...

    FieldValidatorDel _fieldValidatorDel = null;
    ...

    string[] _fieldArray = null;
    ...

    public FieldValidatorDel ValidatorDel => _fieldValidatorDel;

    public void InitialiseValidatorDelegates()
    {
        _fieldValidatorDel = new FieldValidatorDel(ValidateField);

        _requiredValidDel = CommonFieldValidatorFunctions.RequiredFieldValidDel;
        _stringLengthValidDel = CommonFieldValidatorFunctions.StringLengthFieldValid;
        _dateValidDel = CommonFieldValidatorFunctions.DateFieldValidDel;
        _pattenMatchValidDel = CommonFieldValidatorFunctions.PattenMatchValidDel;
        _compareFieldsValidDel = CommonFieldValidatorFunctions.FieldsCompareValidDel;
    }
}

public class UserRegistrationValidator : IFieldValidator
{
    const int FirstName_Min_Length = 2;
    ...

    FieldValidatorDel _fieldValidatorDel = null;
    ...

    string[] _fieldArray = null;
    ...

    public FieldValidatorDel ValidatorDel => _fieldValidatorDel;
    ...

    private bool ValidateField(int fieldIndex, string fieldValue, string[] fieldArray, out string fieldInvalidMessage)
    {
        fieldInvalidMessage = "";

        FieldConstants.UserRegistrationField userRegistrationField = (FieldConstants.UserRegistrationField)fieldIndex;

        switch (userRegistrationField) 
        {
            case FieldConstants.UserRegistrationField.EmailAddress:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_pattenMatchValidDel(fieldValue, CommonRegularExpressionValidationPatterns.Email_Address_RegEx_Pattern)) ? $"You must enter a valid email address{Environment.NewLine}" : fieldInvalidMessage;
                break;
        }

        return (fieldInvalidMessage == "");
    }
}

public class UserRegistrationValidator : IFieldValidator
{
    const int FirstName_Min_Length = 2;
    const int FirstName_Max_Length = 100;
    const int LastName_Min_Length = 2;
    const int LastName_Max_Length = 100;

    // Check if the user email already exists in users table
    delegate bool EmailExistsDel(string emailAddress);

    FieldValidatorDel _fieldValidatorDel = null;

    RequiredValidDel _requiredValidDel = null;
    StringLengthValidDel _stringLengthValidDel = null;
    DateValidDel _dateValidDel = null;
    PattenMatchValidDel _pattenMatchValidDel = null;
    CompareFieldsValidDel _compareFieldsValidDel = null;

    EmailExistsDel _emailExistsDel = null;

    string[] _fieldArray = null;

    public string[] FieldArray
    {
        get
        {
            if (_fieldArray == null)
                _fieldArray = new string[Enum.GetValues(typeof(FieldConstants.UserRegistrationField)).Length];
            return _fieldArray;
        }
    }

    public FieldValidatorDel ValidatorDel => _fieldValidatorDel;

    public void InitialiseValidatorDelegates()
    {
        _fieldValidatorDel = new FieldValidatorDel(ValidateField);

        _requiredValidDel = CommonFieldValidatorFunctions.RequiredFieldValidDel;
        _stringLengthValidDel = CommonFieldValidatorFunctions.StringLengthFieldValid;
        _dateValidDel = CommonFieldValidatorFunctions.DateFieldValidDel;
        _pattenMatchValidDel = CommonFieldValidatorFunctions.PattenMatchValidDel;
        _compareFieldsValidDel = CommonFieldValidatorFunctions.FieldsCompareValidDel;
    }

    private bool ValidateField(int fieldIndex, string fieldValue, string[] fieldArray, out string fieldInvalidMessage)
    {
        fieldInvalidMessage = "";

        FieldConstants.UserRegistrationField userRegistrationField = (FieldConstants.UserRegistrationField)fieldIndex;

        switch (userRegistrationField) 
        {
            case FieldConstants.UserRegistrationField.EmailAddress:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_pattenMatchValidDel(fieldValue, CommonRegularExpressionValidationPatterns.Email_Address_RegEx_Pattern)) ? $"You must enter a valid email address{Environment.NewLine}" : fieldInvalidMessage;
                fieldInvalidMessage = (fieldInvalidMessage == "" && _emailExistsDel(fieldValue)) ? $"This email address already exists{Environment.NewLine}" : fieldInvalidMessage;
                break;

            case FieldConstants.UserRegistrationField.FirstName:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_stringLengthValidDel(fieldValue, FirstName_Min_Length, FirstName_Max_Length)) ? $"{Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)} must be between {FirstName_Min_Length} and {FirstName_Max_Length}{Environment.NewLine}" : fieldInvalidMessage;
                break;
            case FieldConstants.UserRegistrationField.LastName:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_stringLengthValidDel(fieldValue, LastName_Min_Length, LastName_Max_Length)) ? $"{Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)} must be between {LastName_Min_Length} and {LastName_Max_Length}{Environment.NewLine}" : fieldInvalidMessage;
                break;
            case FieldConstants.UserRegistrationField.Password:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_pattenMatchValidDel(fieldValue, CommonRegularExpressionValidationPatterns.Strong_Password_RegEx_Pattern)) ? $"Your password must contain at least 1 small-case letter, 1 capital letter, 1 special character and the length should be between 6-10 letters{Environment.NewLine}" : fieldInvalidMessage;
                break;
            case FieldConstants.UserRegistrationField.PasswordCompare:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_compareFieldsValidDel(fieldValue, fieldArray[(int)FieldConstants.UserRegistrationField.Password])) ? $"Your entry did not match your password{Environment.NewLine}" : fieldInvalidMessage;
                break;
            case FieldConstants.UserRegistrationField.DateOfBirth:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_dateValidDel(fieldValue, out DateTime validDateTime)) ? $"You didn't enter a valid date{Environment.NewLine}" : fieldInvalidMessage;
                break;
            case FieldConstants.UserRegistrationField.PhoneNumber:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_pattenMatchValidDel(fieldValue, CommonRegularExpressionValidationPatterns.Uk_PhoneNumber_RegEx_Pattern)) ? $"You didn't enter a valid UK phone number{Environment.NewLine}" : fieldInvalidMessage;
                break;
            case FieldConstants.UserRegistrationField.AddressFirstLine:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                break;
            case FieldConstants.UserRegistrationField.AddressSecondLine:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                break;
            case FieldConstants.UserRegistrationField.AddressCity:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                break;
            case FieldConstants.UserRegistrationField.PostCode:
                fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
                fieldInvalidMessage = (fieldInvalidMessage == "" && !_pattenMatchValidDel(fieldValue, CommonRegularExpressionValidationPatterns.Uk_Post_Code_RegEx_Pattern)) ? $"You didn't enter a valid UK post code{Environment.NewLine}" : fieldInvalidMessage;
                break;
            default:
                throw new ArgumentException("This field does not exist");
        }

        // If no other message returned, the field is valid
        return (fieldInvalidMessage == "");
    }
}

public interface IRegister
{
    // Valid field data from the user input -> to save to the DB
    bool Register(string[] fields);
    bool EmailExists(string emailAddress);
}

public interface ILogin
{
    User Login(string emailAddress, string password);
}

public class RegisterUser : IRegister
{
    public bool EmailExists(string emailAddress)
    {
        throw new NotImplementedException();
    }

    public bool Register(string[] fields)
    {
        using(var dbContext = new ClubMembershipDbContext()) 
        {
            User user = new User
            {
                EmailAddress = fields[(int)FieldConstants.UserRegistrationField.EmailAddress],
                FirstName = fields[(int)FieldConstants.UserRegistrationField.FirstName],
                LastName = fields[(int)FieldConstants.UserRegistrationField.LastName],
                Password = fields[(int)FieldConstants.UserRegistrationField.Password],
                DateOfBirth = DateTime.Parse(fields[(int)FieldConstants.UserRegistrationField.DateOfBirth]),
                PhoneNumber = fields[(int)FieldConstants.UserRegistrationField.PhoneNumber],
                AddressFirstLine = fields[(int)FieldConstants.UserRegistrationField.AddressFirstLine],
                AddressSecondtLine = fields[(int)FieldConstants.UserRegistrationField.AddressSecondtLine],
                AddressCity = fields[(int)FieldConstants.UserRegistrationField.AddressCity],
                PostCode = fields[(int)FieldConstants.UserRegistrationField.PostCode],
            };

            dbContext.Users.Add(user);
            dbContext.SaveChanges();
        }
        return true;
    }
}

public bool EmailExists(string emailAddress)
{
    bool emailExists = false;

    using(var dbContext = new ClubMembershipDbContext()) 
    {
        emailExists = dbContext.Users.Any(user => user.EmailAddress.ToLower().Trim() == emailAddress.ToLower().Trim());
    }

    return emailExists;
}

public class LoginUser : ILogin
{
    public User Login(string emailAddress, string password)
    {
        User user = null;

        using (var dbContext = new ClubMembershipDbContext()) {
            user = dbContext.Users.FirstOrDefault(u => u.EmailAddress.Trim().ToLower() == emailAddress.Trim().ToLower() && u.Password.Equals(password));
        }
        return user;
    }
}

IRegister? _register = null;

public void InitialiseValidatorDelegates()
{
    _fieldValidatorDel = new FieldValidatorDel(ValidateField);
    _emailExistsDel = new EmailExistsDel(_register.EmailExists);

    _requiredValidDel = CommonFieldValidatorFunctions.RequiredFieldValidDel;
    _stringLengthValidDel = CommonFieldValidatorFunctions.StringLengthFieldValid;
    _dateValidDel = CommonFieldValidatorFunctions.DateFieldValidDel;
    _pattenMatchValidDel = CommonFieldValidatorFunctions.PattenMatchValidDel;
    _compareFieldsValidDel = CommonFieldValidatorFunctions.FieldsCompareValidDel;
}

private bool ValidateField(int fieldIndex, string fieldValue, string[] fieldArray, out string fieldInvalidMessage)
{
    fieldInvalidMessage = "";

    FieldConstants.UserRegistrationField userRegistrationField = (FieldConstants.UserRegistrationField)fieldIndex;

    switch (userRegistrationField) 
    {
        case FieldConstants.UserRegistrationField.EmailAddress:
            fieldInvalidMessage = (!_requiredValidDel(fieldValue)) ? $"You must enter a value for field: {Enum.GetName(typeof(FieldConstants.UserRegistrationField), userRegistrationField)}{Environment.NewLine}" : "";
            fieldInvalidMessage = (fieldInvalidMessage == "" && !_pattenMatchValidDel(fieldValue, CommonRegularExpressionValidationPatterns.Email_Address_RegEx_Pattern)) ? $"You must enter a valid email address{Environment.NewLine}" : fieldInvalidMessage;
            fieldInvalidMessage = (fieldInvalidMessage == "" && !_emailExistsDel(fieldValue)) ? $"This email address already exists{Environment.NewLine}" : fieldInvalidMessage;
            break;

...
}

public UserRegistrationValidator(IRegister register)
{
    _register = register;
}

public static class CommonOutputText
{
    private static string MainHeading
    {
        get
        {
            string heading = "Cycling Club";
            return $"{heading}{Environment.NewLine}{new string('-', heading.Length)}";
        }
    }

    private static string RegistrationHeading
    {
        get
        {
            string heading = "Register";
            return $"{heading}{Environment.NewLine}{new string('-', heading.Length)}";
        }
    }

    private static string LoginHeading
    {
        get
        {
            string heading = "Login";
            return $"{heading}{Environment.NewLine}{new string('-', heading.Length)}";
        }
    }

    public static void WriteMainHeading()
    {
        Console.Clear();
        Console.WriteLine(MainHeading);
        Console.WriteLine();
        Console.WriteLine();
    }

    public static void WriteLoginHeading()
    {
        Console.Clear();
        Console.WriteLine(MainHeading);
        Console.WriteLine();
        Console.WriteLine();
    }

    public static void WriteRegistrationHeading()
    {
        Console.Clear();
        Console.WriteLine(MainHeading);
        Console.WriteLine();
        Console.WriteLine();
    }
}

public enum FontTheme
{
    Default,
    Danger,
    Success
}

public static class CommonOutputFormat
{
    public static void ChangeFontColor(FontTheme fontTheme)
    {
        if(fontTheme == FontTheme.Danger) {
            Console.BackgroundColor = ConsoleColor.Red;
            Console.ForegroundColor = ConsoleColor.White;
        }
        else if (fontTheme == FontTheme.Success) {
            Console.BackgroundColor = ConsoleColor.Green;
            Console.ForegroundColor = ConsoleColor.White;
        } else {
            Console.ResetColor();
        }
    }
}

public interface IView
{
    void RunView();
    IFieldValidator FieldValidator { get; set; }
}

public class UserRegistrationView : IView
{
    IFieldValidator _fieldValidator = null;
    IRegister _register = null;

    public IFieldValidator FieldValidator { get => _fieldValidator; }

    public UserRegistrationView(IRegister register, IFieldValidator fieldValidator)
    {
        _fieldValidator = fieldValidator;
        _register = register;
    }

    public void RunView()
    {
        CommonOutputText.WriteRegistrationHeading();
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.EmailAddress] = GetInputFromUser(FieldConstants.UserRegistrationField.EmailAddress, "Please enter your email address: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.FirstName] = GetInputFromUser(FieldConstants.UserRegistrationField.FirstName, "Please enter your first name: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.LastName] = GetInputFromUser(FieldConstants.UserRegistrationField.LastName, "Please enter your last name: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.Password] = GetInputFromUser(FieldConstants.UserRegistrationField.Password, $"Please enter your password.
            {Environment.NewLine}Your password must contain at least 1 small-case letter,{Environment.NewLine}1 Capital letter, 1 digit, 1 special character{Environment.NewLine} and the length should be between 6-10 characters: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.PasswordCompare] = GetInputFromUser(FieldConstants.UserRegistrationField.PasswordCompare, "Please re-enter your email address: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.DateOfBirth] = GetInputFromUser(FieldConstants.UserRegistrationField.DateOfBirth, "Please enter your date of birth: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.AddressFirstLine] = GetInputFromUser(FieldConstants.UserRegistrationField.AddressFirstLine, "Please enter your first adress line: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.AddressSecondLine] = GetInputFromUser(FieldConstants.UserRegistrationField.AddressSecondLine, "Please enter your second adress line: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.AddressCity] = GetInputFromUser(FieldConstants.UserRegistrationField.AddressCity, "Please enter your address city: ");
        _fieldValidator.FieldArray[(int)FieldConstants.UserRegistrationField.PostCode] = GetInputFromUser(FieldConstants.UserRegistrationField.PostCode, "Please enter your postal code: ");

        RegisterUser();
    }

    private void RegisterUser()
    {
        _register.Register(_fieldValidator.FieldArray);

        CommonOutputFormat.ChangeFontColor(FontTheme.Success);
        Console.WriteLine("You have successfully registered. Please press any key to login.");
        CommonOutputFormat.ChangeFontColor(FontTheme.Default);
    }

    private string GetInputFromUser(FieldConstants.UserRegistrationField field, string promptText)
    {
        string fieldVal = "";

        // The prompt will go on until a valid field value will be entered.
        do {
            Console.Write(promptText);
            fieldVal = Console.ReadLine();
        } while (!FieldValid(field, fieldVal));

        return fieldVal;
    }

    private bool FieldValid(FieldConstants.UserRegistrationField field, string fieldValue)
    {
        if (!_fieldValidator.ValidatorDel((int)field, fieldValue, _fieldValidator.FieldArray, out string invalidMessage)) {
            CommonOutputFormat.ChangeFontColor(FontTheme.Danger);
            Console.WriteLine(invalidMessage);
            CommonOutputFormat.ChangeFontColor(FontTheme.Default);

            return false;
        }
        return true;
    }
}

public class UserLoginView : IView
{
    ILogin _loginUser = null;
    public IFieldValidator FieldValidator => null;

    public UserLoginView(ILogin login)
    {
        _loginUser = login;
    }

    public void RunView()
    {
        CommonOutputText.WriteMainHeading();
        CommonOutputText.WriteLoginHeading();

        Console.WriteLine("Please enter your email address");
        string emailAddress = Console.ReadLine();

        Console.WriteLine("Please enter your password");
        string password = Console.ReadLine();

        User user = _loginUser.Login(emailAddress, password);
        if(user != null) {
            WelcomeUserView welcomeUserView = new WelcomeUserView(user);
            welcomeUserView.RunView();
        } else {
            Console.Clear();
            CommonOutputFormat.ChangeFontColor(FontTheme.Danger);
            Console.WriteLine("The credentials that you entered do not match any of our records");
            CommonOutputFormat.ChangeFontColor(FontTheme.Default);
            Console.ReadKey();
        }
    }
}

public class WelcomeUserView : IView
{
    User _user = null;

    public WelcomeUserView(User user)
    {
        _user = user;
    }

    public IFieldValidator FieldValidator => null;

    public void RunView()
    {
        Console.Clear();
        CommonOutputText.WriteMainHeading();

        CommonOutputFormat.ChangeFontColor(FontTheme.Success);
        Console.WriteLine($"Hi {_user.FirstName}!!{Environment.NewLine}Welcome to the Cycling Club!!");
        CommonOutputFormat.ChangeFontColor(FontTheme.Default);
        Console.ReadKey();
    }
}

public class MainView : IView
{
    public IFieldValidator FieldValidator => null;

    IView _registerView = null;
    IView _loginView = null;

    public MainView(IView registerView, IView loginView)
    {
        _registerView = registerView;
        _loginView = loginView;
    }
    public void RunView()
    {
        CommonOutputText.WriteMainHeading();

        Console.WriteLine("Please press 'l' to login or if you are not yet registered please press 'r'");
        ConsoleKey key = Console.ReadKey().Key;

        if (key == ConsoleKey.R) {
            RunUserRegistrationView();
            RunLoginView();
        }
        else if (key == ConsoleKey.L) {
            RunLoginView();
        }
        else {
            Console.Clear();
            Console.WriteLine("Goodbye");
            Console.ReadKey();
        }
    }

    private void RunUserRegistrationView()
    {
        _registerView.RunView();
    }

    private void RunLoginView()
    {
        _loginView.RunView();
    }
}

public static class Factory
{
    public static IView GetMainViewObject()
    {
        ILogin login = new LoginUser();
        IRegister register = new RegisterUser();
        IFieldValidator userRegistrationValidator = new UserRegistrationValidator(register);
        userRegistrationValidator.InitialiseValidatorDelegates();

        IView registerView = new UserRegistrationView(register, userRegistrationValidator);
        IView loginView = new UserLoginView(login);
        IView mainView = new MainView(registerView, loginView);

        return mainView;
    }
}

IView mainView = Factory.GetMainViewObject();
mainView.RunView();

Console.ReadKey();