C#

var companyTask = _apiProxy.GetNavigationItems(NavigationItemType.Company);
var employeeTask = _apiProxy.GetNavigationItems(NavigationItemType.Employee);
var projectTask = _apiProxy.GetNavigationItems(NavigationItemType.Project);

var companies = await companyTask;
var employees = await employeeTask;
var projects = await projectTask;

Kevin Marois wrote:

I want to run a these commands in parallel and get the results as each finishes.

var tasks = new List<Task<T>>
{
    _apiProxy.GetNavigationItems(NavigationItemType.Company),
    _apiProxy.GetNavigationItems(NavigationItemType.Employee),
    _apiProxy.GetNavigationItems(NavigationItemType.Project)
};

while (tasks.Count != 0)
{
    var t = await Task.WhenAny(tasks);
    tasks.Remove(t);
    
    T result = await t;
    // Process the results here...
}

int numLoCase = ...
int numUpCase = ...
int numSpaces = ...
int numNumeric = ...
int numSpecial = ...
int len = ...

if (len >= 10 
    && len <= 50   
    && numSpaces == 0
    && ...

Jassim Rahma wrote:

Password MUST be a minimum of 10 AND maximum of 50
It should NOT contain space.
It should be MIXED alphabet (upper + lower), numeric and following special characters !@#$%^&*-_+=~

Bastard Programmer from Hell
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.

bool IsValidPassword(string password, 
            int minLength=10, 
            int maxLength=50, 
            bool requireLowercase=true, 
            bool requireUppercase=false, 
            bool requireNumber=false,
            bool requireSimbol=false)
        {
            if (string.IsNullOrEmpty(password))
            {
                return false;
            }
            if (password.Length < minLength || password.Length > maxLength)
            {
                return false;
            }
            if (requireUppercase && !Regex.IsMatch(password, "[A-Z]"))
            {
                return false;
            }
            if (requireLowercase && !Regex.IsMatch(password, "[a-z]"))
            {
                return false;
            }
            if (requireNumber && !Regex.IsMatch(password, "[0-9]"))
            {
                return false;
            }
            string pattern= @"[!@#$%^&*()_+\-=\[\]{};':" + "\"" + @"\\|,.<>\/? ~]";
            if (requireSimbol && !Regex.IsMatch(password, pattern))
                return false;
            return true;
        }

#region Event Handlers
#region Form
/// <summary>
/// Restore size and location (if the user doesn't
/// override it)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FrmMain_Load(object sender, EventArgs e)
    {
    if ((ModifierKeys & Keys.Shift) == 0)
        {
        this.LoadLocation();
        }
    }
/// <summary>
/// Save the size and location (if the user doesn't
/// override it)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
    {
    if ((ModifierKeys & Keys.Shift) == 0)
        {
        this.SaveLocation();
        }
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Data;
using System.Drawing;
using System.Diagnostics;

namespace OneOffJobs
    {
    /// <summary>
    /// Provides the storage related code
    /// </summary>
    public static class Storage
        {
        #region Constants
        /// <summary>
        /// Restore command, used as a parameter to ShowWindow
        /// </summary>
        private const int SW_RESTORE = 9;
        #endregion

        #region DLL Imports
        // Sets the window to be foreground
        [DllImport("User32")]
        private static extern int SetForegroundWindow(IntPtr hwnd);
        // Activate or minimize a window
        [DllImportAttribute("User32.DLL")]
        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
        #endregion

        #region Fields
        #region Internal
        #endregion

        #region Property bases
        #endregion
        #endregion

        #region Properties
        /// <summary>
        /// Get the Application Guid
        /// </summary>
        public static Guid AppGuid
            {
            get
                {
                Assembly asm = Assembly.GetEntryAssembly();
                object[] attr = (asm.GetCustomAttributes(typeof(GuidAttribute), true));
                return new Guid((attr[0] as GuidAttribute).Value);
                }
            }
        /// <summary>
        /// Get the current assembly Guid.
        /// <remarks>
        /// Note that the Assembly Guid is not necessarily the same as the
        /// Application Guid - if this code is in a DLL, the Assembly Guid
        /// will be the Guid for the DLL, not the active EXE file.
        /// </remarks>
        /// </summary>
        public static Guid AssemblyGuid
            {
            get
                {
                Assembly asm = Assembly.GetExecutingAssembly();
                object[] attr = (asm.GetCustomAttributes(typeof(GuidAttribute), true));
                return new Guid((attr[0] as GuidAttribute).Value);
                }
            }
        /// <summary>
        /// Get the current user data folder
        /// </summary>
        public static string UserDataFolder
            {
            get
                {
                Guid appGuid = AppGuid;
                string folderBase = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
                string dir = string.Format(@"{0}\{1}\", folderBase, appGuid.ToString("B").ToUpper());
                return CheckDir(dir);
                }
            }
        /// <summary>
        /// Get the current user roaming data folder
        /// </summary>
        public static string UserRoamingDataFolder
            {
            get
                {
                Guid appGuid = AppGuid;
                string folderBase = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
                string dir = string.Format(@"{0}\{1}\", folderBase, appGuid.ToString("B").ToUpper());
                return CheckDir(dir);
                }
            }
        /// <summary>
        /// Get all users data folder
        /// </summary>
        public static string AllUsersDataFolder
            {
            get
                {
                Guid appGuid = AppGuid;
                string folderBase = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
                string dir = string.Format(@"{0}\{1}\", folderBase, appGuid.ToString("B").ToUpper());
                return CheckDir(dir);
                }
            }
        /// <summary>
        /// Location to store control locations in.
        /// </summary>
        public static string LocationsStorageFile { get; private set; }
        #endregion

        #region Regular Expressions
        #endregion

        #region Enums
        #endregion

        #region Constructors
        /// <summary>
        /// Fill out the static properties
        /// </summary>
        static Storage()
            {
            LocationsStorageFile = UserDataFolder + "control.storage.locations";
            }
        #endregion

        #region Events
        #region Event Constructors
        #endregion

        #region Event Handlers
        #endregion
        #endregion

        #region Public Methods
        /// <summary>
        /// Save the control location
        /// (Because a Form is derived from Control, it works
        /// for them as well)
        /// </summary>
        /// <param name="control">Form to save location of</param>
        /// <param name="instance">Instance identifier (for use with multiple instances)</param>
        public static void SaveLocation(this Control control, string instance = null)
            {
            string controlName = control.GetType().Name;
            if (!File.Exists(LocationsStorageFile))
                {
                CreateBlankLocationFile();
                }
            if (!(control is Form f) || (f.Visible && f.WindowState == FormWindowState.Normal))
                {
                // For Forms, we don't want to save if hidden, or if maximized / minimized
                // If we did, it causes the form to be misplaced, or far too small to see.
                DataTable dt = ReadXML(LocationsStorageFile);
                if (dt.Columns.Count >= 6)
                    {
                    bool ignoreInstance = string.IsNullOrWhiteSpace(instance);
                    DataRow current = dt.NewRow();    // Assume new row or instance.
                    current["ControlName"] = controlName;
                    current["Instance"] = instance ?? "";
                    foreach (DataRow row in dt.Rows)
                        {
                        if (row["ControlName"] as string == controlName && (ignoreInstance || row["Instance"] as string == instance))
                            {
                            // Found it!
                            //current = row;
                            dt.Rows.Remove(row);
                            break;
                            }
                        }
                    current["LocationX"] = control.Location.X;
                    current["LocationY"] = control.Location.Y;
                    current["SizeW"] = control.Size.Width;
                    current["SizeH"] = control.Size.Height;
                    dt.Rows.Add(current);
                    WriteXML(dt, LocationsStorageFile);
                    }
                }
            }
        /// <summary>
        /// Load the Control location
        /// (Because a Form is derived from Control, it works
        /// for them as well)
        /// </summary>
        /// <param name="control">Form to load location of</param>
        /// <param name="instance">Instance identifier (for use with multiple instances)</param>
        public static void LoadLocation(this Control control, string instance = null)
            {
            string controlName = control.GetType().Name;
            if (!File.Exists(LocationsStorageFile))
                {
                CreateBlankLocationFile();
                }
            DataTable dt = ReadXML(LocationsStorageFile);
            if (dt.Columns.Count >= 6)
                {
                bool ignoreInstance = string.IsNullOrWhiteSpace(instance);
                DataRow current = dt.NewRow();    // Assume new row or instance.
                current["ControlName"] = controlName;
                current["Instance"] = instance ?? "";
                current["LocationX"] = control.Location.X;
                current["LocationY"] = control.Location.Y;
                current["SizeW"] = control.Size.Width;
                current["SizeH"] = control.Size.Height;
                foreach (DataRow row in dt.Rows)
                    {
                    if (row["ControlName"] as string == controlName && (ignoreInstance || row["Instance"] as string == instance))
                        {
                        // Found it!
                        current = row;
                        if (int.TryParse(current["LocationX"].ToString(), out int x) &&
                            int.TryParse(current["LocationY"].ToString(), out int y) &&
                            int.TryParse(current["SizeW"].ToString(), out int w) &&
                            int.TryParse(current["SizeH"].ToString(), out int h))
                            {
                            control.Location = new Point(x, y);
                            control.Size = new Size(w, h);
                            }
                        break;
                        }
                    }
                }
            }
        /// <summary>
        /// Ensures that just a single instance of an application is running.
        /// </summary>
        /// <remarks>
        /// Checks if this is the only executing example of this process.
        /// If it is, all well and good.
        /// Otherwise, switches the focus to the other instance, and 
        /// terminates this process.
        /// </remarks>
        /// <example>
        /// In program.cs:
        /// 
        /// [STAThread]
        /// static void Main()
        ///     {
        ///     Process.GetCurrentProcess().SingleInstance();
        ///     Application.EnableVisualStyles();
        ///     Application.SetCompatibleTextRenderingDefault(false);
        ///     Application.Run(new frmMain());
        ///     }
        /// </example>
        /// <param name="thisProcess"></param>
        public static void SingleInstance(this Process thisProcess)
            {
            foreach (Process proc in Process.GetProcessesByName(thisProcess.ProcessName))
                {
                if (proc.Id != thisProcess.Id)
                    {
                    ShowWindow(proc.MainWindowHandle, SW_RESTORE);
                    SetForegroundWindow(proc.MainWindowHandle);
                    thisProcess.Kill();
                    }
                }
            }
        #endregion

        #region Overrides
        #endregion

        #region Private Methods
        /// <summary>
        /// Check the specified folder, and create if it doesn't exist.
        /// </summary>
        /// <param name="dir"></param>
        /// <returns></returns>
        private static string CheckDir(string dir)
            {
            if (!Directory.Exists(dir))
                {
                Directory.CreateDirectory(dir);
                }
            return dir;
            }
        /// <summary>
        /// Read the data from the XML file
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        private static DataTable ReadXML(string file)
            {
            using (DataSet ds = new DataSet())
                {
                ds.ReadXml(file);
                DataTable dt;
                if (ds.Tables.Count > 0)
                    {
                    // Can't leave it attached to the DataSet, even if the set is Disposed!
                    dt = ds.Tables[0];
                    ds.Tables.Remove(dt);
                    }
                else
                    {
                    dt = new DataTable("Empty");
                    }
                return dt;
                }
            }
        /// <summary>
        /// Write the data to the XML file
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="file"></param>
        private static void WriteXML(DataTable dt, string file)
            {
            using (DataSet ds = new DataSet())
                {
                ds.Tables.Add(dt);
                ds.WriteXml(file);
                ds.Tables.Remove(dt);
                }
            }
        /// <summary>
        /// Create a blank file template
        /// </summary>
        private static void CreateBlankLocationFile()
            {
            DataTable dtNew = new DataTable("Locations");
            dtNew.Columns.Add("ControlName", typeof(string));
            dtNew.Columns.Add("Instance", typeof(string));
            dtNew.Columns.Add("LocationX", typeof(int));
            dtNew.Columns.Add("LocationY", typeof(int));
            dtNew.Columns.Add("SizeW", typeof(int));
            dtNew.Columns.Add("SizeH", typeof(int));
            DataRow dr = dtNew.NewRow();
            dr["ControlName"] = "%%SAMPLE%%";
            dr["Instance"] = "%%INSTANCE%%";
            dr["LocationX"] = 0;
            dr["LocationY"] = 0;
            dr["SizeW"] = 200;
            dr["SizeH"] = 200;
            dtNew.Rows.Add(dr);
            WriteXML(dtNew, LocationsStorageFile);
            }
        #endregion
        }
    }

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

namespace multimonitor1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Abrufen der DPI-Skalierung und Skalierungsstufe jedes Bildschirms
            List<(float, float, int)> screenDpiScales = new List<(float, float, int)>();

            while (true)
            {
                foreach (Screen screen in Screen.AllScreens)
                {
                    using (var form = new Form() { Bounds = screen.Bounds, TopMost = true })
                    {
                        form.Show();

                        Graphics g = Graphics.FromHwnd(form.Handle);

                        float	dpiX	= g.DpiX;
                        float	dpiY	= g.DpiY;
                        int		scale	= (int) Math.Round(dpiX / 96.0 * 100);
                        
						screenDpiScales.Add((dpiX, dpiY, scale));
                        
						form.Hide();
                    }
                }

                // Ermitteln der Größe und Position der Anwendung
                int appLeft		= 0;
                int appTop		= 0;
                int appWidth	= 0;
                int appHeight	= 0;

                // Hier müssen die genauen Koordinaten der Anwendung in Bezug auf den Bildschirm ermittelt werden.
                // *** [English] The exact coordinates of the application in relation to the screen must be determined here. ***

                // Berechnen der Größe und Position der Anwendung auf jedem Bildschirm
                for (int i = 0; i < Screen.AllScreens.Length; i++)
                {
                    Screen screen = Screen.AllScreens[i];

                    (float, float, int) dpiScale = screenDpiScales[i];

                    Rectangle screenBounds = screen.Bounds;

                    float	dpiX	= dpiScale.Item1;
                    float	dpiY	= dpiScale.Item2;
                    int		scale	= dpiScale.Item3;

                    appLeft		= (int) (appLeft	* screenBounds.Width	/ (dpiX / 96.0 * scale));
                    appTop		= (int) (appTop		* screenBounds.Height	/ (dpiY / 96.0 * scale));
                    appWidth	= (int) (appWidth	* screenBounds.Width	/ (dpiX / 96.0 * scale));
                    appHeight	= (int) (appHeight	* screenBounds.Height	/ (dpiY / 96.0 * scale));

                    // Ausgabe der Größe und Position der Anwendung
                    Console.WriteLine($"Left:   {appLeft}");
                    Console.WriteLine($"Top:    {appTop}");
                    Console.WriteLine($"Width:  {appWidth}");
                    Console.WriteLine($"Height: {appHeight}");
                }

                Console.ReadLine();
            }
        }
    }
}