C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

public class Path
{
    public string CurrentPath { get; private set; }

    public Path(string path)
    {
        this.CurrentPath = path;
    }

    public Path Cd(string newPath)
    {
        Path pathStr = new Path(this.CurrentPath);
        if (newPath == null | newPath == string.Empty)
        {
            throw new System.NotSupportedException("Waiting to be implemented.");
        }

        string patternUp = "([\\.]{2}/)+[a-zA-z]+";
        string patternDown = @"/([a-zA-z]*)";

        var matchesUp = Regex.Matches(newPath, patternUp);
        var matchesDown = Regex.Matches(newPath, patternDown);

        if (matchesUp.Count > 0)
        {
            var countUp = newPath.Count(c => c == '.');

            pathStr.CurrentPath = pathStr.CurrentPath.Substring(0, pathStr.CurrentPath.Length - countUp);
            pathStr.CurrentPath = pathStr.CurrentPath + "/" + newPath.Replace("../", "");
        }
        else
        {
            pathStr.CurrentPath = pathStr.CurrentPath  + newPath.Replace("../", "");
        }
        return new Path(pathStr.CurrentPath);
    }

    public static void Main(string[] args)
    {
        Path path = new Path("/a/b/c/d");
        Console.WriteLine(path.Cd("../x").CurrentPath);
    }
}

private void ImportData_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            #region Delete Previous Data...
            if (MessageBox.Show("Delete all previous records?", "DELETE ALL", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes)
            {
                if (MessageBox.Show("ALL RECORDS WILL BE DELETED PERMANENTLY... ARE YOU SURE?", "DELETE ALL", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes)
                {
                    lblMessage.Content = "Please wait...";
                    Cursor = Cursors.Wait;
                    Engine E = new Engine();
                    SQLiteCommand CMD = new SQLiteCommand("DELETE FROM YEARS", E.Conn);
                    CMD.ExecuteNonQuery();
                    CMD = new SQLiteCommand("DELETE FROM WARDS", E.Conn);
                    CMD.ExecuteNonQuery();
                    CMD = new SQLiteCommand("DELETE FROM USERS", E.Conn);
                    CMD.ExecuteNonQuery();
                    CMD = new SQLiteCommand("DELETE FROM SETTINGS", E.Conn);
                    CMD.ExecuteNonQuery();

                    E.Dispose();
                    CMD.Dispose();
                    Cursor = null;
                }
                else goto Import;
            }
            #endregion

        Import:
            ButtonsPanel.IsEnabled = false;
            FrmClose.IsEnabled = false;

            BW.WorkerSupportsCancellation = false;
            BW.WorkerReportsProgress = true;
            BW.WorkerSupportsCancellation = false;
            BW.DoWork += BW_DoWork;
            BW.ProgressChanged += BW_ProgressChanged;
            BW.RunWorkerCompleted += BW_RunWorkerCompleted;
            BW.RunWorkerAsync();

            lblMessage.Content = "Done...";
            ButtonsPanel.IsEnabled = true;
            FrmClose.IsEnabled = true;
        }
        void BW_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            lblMessage.Content = "Done...";
            Progress.Value = 0;
        }
        void BW_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            Progress.Value = e.ProgressPercentage;
        }
        void BW_DoWork(object sender, DoWorkEventArgs e)
        {
            Progress.Value = 0;
            #region YearlyTax...
            var INF = new IniFile(Path.Combine(Directories.OLD_DATAFOLDER, @"yt.txn")); // Error in this line (Cross-Thread) IniFile is another static class in another file.
            string[] T = INF.GetSectionNames();
            Progress.Maximum = T.Length;

            foreach (string M in T)
            {
                SQLiteCommand CMD = new SQLiteCommand(E.InsertSQL("YEARS"), E.Conn);

                CMD.Parameters.AddWithValue("ID", Guid.NewGuid().ToString());
                CMD.Parameters.AddWithValue("YEAR", M);
                CMD.Parameters.AddWithValue("B6000", INF.GetDouble(M, "txt6000"));
                CMD.Parameters.AddWithValue("I12000", INF.GetDouble(M, "txt12000"));
                CMD.Parameters.AddWithValue("I100000", INF.GetDouble(M, "txt100000"));
                CMD.Parameters.AddWithValue("I150000", INF.GetDouble(M, "txt150000"));
                CMD.Parameters.AddWithValue("I200000", INF.GetDouble(M, "txt200000"));
                CMD.Parameters.AddWithValue("I250000", INF.GetDouble(M, "txt250000"));
                CMD.Parameters.AddWithValue("A250000", INF.GetDouble(M, "txtabove250000"));
                CMD.Parameters.AddWithValue("SAMEKIT", INF.GetDouble(M, "samekit"));
                CMD.Parameters.AddWithValue("VIVRANI", INF.GetDouble(M, "vivraniprapatrashulk"));
                CMD.Parameters.AddWithValue("LATEFEESPERCENT", INF.GetDouble(M, "latefees"));
                CMD.Parameters.AddWithValue("HOUSINGDISCOUNTPERCENT", INF.GetDouble(M, "housingdiscount"));
                CMD.Parameters.AddWithValue("OWNERDISCOUNTPERCENT", INF.GetDouble(M, "completeownerdiscountpercent"));
                CMD.Parameters.AddWithValue("WIDOWDISCOUNT", INF.GetDouble(M, "concessiontypediscount"));

                CMD.ExecuteNonQuery();

                lblMessage.Content = "Importing: " + M;
                BW.ReportProgress(P++);
                Thread.Sleep(30);
            }
            #endregion
            BW.ReportProgress(0);
            #region Wards...
            T = Directory.GetFiles(Path.Combine(Directories.OLD_DATAFOLDER, "Wards"), "*.wrd", SearchOption.AllDirectories);
            foreach (string M in T)
            {
                INF = new IniFile(M);
                string[] Q = INF.GetSectionNames();

                foreach (string L in Q)
                {
                    SQLiteCommand CMD = new SQLiteCommand(E.InsertSQL("WARDS"), E.Conn);

                    CMD.Parameters.AddWithValue("ID", Guid.NewGuid().ToString());
                    CMD.Parameters.AddWithValue("WARDNUMBER", Convert.ToInt32(L));
                    CMD.Parameters.AddWithValue("ZONE", INF.GetInt32(L, "zone"));
                    CMD.Parameters.AddWithValue("NAME", INF.GetString(L, "name"));
                    CMD.Parameters.AddWithValue("MANAGER", string.Empty);
                    CMD.Parameters.AddWithValue("N1", INF.GetDouble(L, "m1"));
                    CMD.Parameters.AddWithValue("N2", INF.GetDouble(L, "m2"));
                    CMD.Parameters.AddWithValue("N3", INF.GetDouble(L, "m3"));
                    CMD.Parameters.AddWithValue("ON1", INF.GetDouble(L, "mn1"));
                    CMD.Parameters.AddWithValue("ON2", INF.GetDouble(L, "mn2"));
                    CMD.Parameters.AddWithValue("ON3", INF.GetDouble(L, "mn3"));
                    CMD.Parameters.AddWithValue("IN1", INF.GetDouble(L, "vm1"));
                    CMD.Parameters.AddWithValue("IN2", INF.GetDouble(L, "vm2"));
                    CMD.Parameters.AddWithValue("IN3", INF.GetDouble(L, "vm3"));
                    CMD.Parameters.AddWithValue("OIN1", INF.GetDouble(L, "vmn1"));
                    CMD.Parameters.AddWithValue("OIN2", INF.GetDouble(L, "vmn2"));
                    CMD.Parameters.AddWithValue("OIN3", INF.GetDouble(L, "vmn3"));

                    CMD.ExecuteNonQuery();
                    lblMessage.Content = "Importing: " + M;
                    BW.ReportProgress(P++);
                    Thread.Sleep(30);
                }
            }
            #endregion
            BW.ReportProgress(0);
            #region Customers...
            T = Directory.GetFiles(Path.Combine(Directories.OLD_DATAFOLDER, "Customer"), "custdata.cst", SearchOption.AllDirectories);
            P = 0;
            foreach (string M in T)
            {
                INF = new IniFile(M);

                SQLiteCommand CMD = new SQLiteCommand(E.InsertSQL("Customers"), E.Conn);

                CMD.Parameters.AddWithValue("ID", Guid.NewGuid().ToString());
                CMD.Parameters.AddWithValue("DEMAND", CheckDemand(INF.GetString("data", "voterid")));
                CMD.Parameters.AddWithValue("AADHAR", INF.GetString("data", "aadhar").Trim());
                CMD.Parameters.AddWithValue("WARDNUMBER", INF.GetInt32("data", "wno"));
                CMD.Parameters.AddWithValue("NAME", INF.GetString("data", "name").Trim());
                CMD.Parameters.AddWithValue("CASTE", INF.GetString("data", "caste").Trim());
                CMD.Parameters.AddWithValue("ADDRESS1", INF.GetString("data", "address1").Trim());
                CMD.Parameters.AddWithValue("ADDRESS2", INF.GetString("data", "address2").Trim());
                CMD.Parameters.AddWithValue("PLOTNUMBER", INF.GetString("data", "plotno").Trim());
                CMD.Parameters.AddWithValue("MOBILENUMBER", INF.GetString("data", "mobile").Trim());
                CMD.Parameters.AddWithValue("LEDGERBALANCE", 0);

                CMD.ExecuteNonQuery();

                lblMessage.Content = "Importing: " + Path.GetFileName(M);
                BW.ReportProgress(P++);
                Thread.Sleep(30);
            }
            #endregion
        }

public MainWindow()
       {
           InitializeComponent();
           Register = new RegistrationHelper();
           var progressInfo = new Progress<string>(p => StatusInfo = p);
           Register.HandleRegistration(progressInfo);
           //and that's it
   }

private const string DefaultApiAddress = "<a href="https://MyApi.azuresites.net">https://MyApi.azuresites.net</a>";
public RegistrationHelper(string email = null)
{
    ApiUri = new Uri(DefaultApiAddress);
    UserName = Environment.UserName;
    MachineName = Environment.MachineName;
    //email is not needed for registration
    UserProvidedEmail = email;
    CurrentAssembly = Assembly.GetEntryAssembly();
    ProgramName = CurrentAssembly.GetName().Name;
    ProgramVersion = FileVersionInfo.GetVersionInfo(CurrentAssembly.Location).FileVersion;
}

public void HandleRegistration(IProgress<string> progressInfo)
{
    Task.Run((() => HandleRegistrationAsync(progressInfo)));
}

private async Task HandleRegistrationAsync(IProgress<string> progressInfo)
{
    try
    {
        progressInfo.Report("Connecting...");
        RegisteredUserId = await GetUserIdAsync();
        if (RegisteredUserId == 0)
        {
            RegisteredUserId = await RegisterUserByNameAsync();
            if (RegisteredUserId > 0)
            {
                progressInfo.Report(string.Format("Newly registered. Id: {0}", RegisteredUserId));
            }
            else
            {
                progressInfo.Report("Registration failed");
            }
        }
        else if (RegisteredUserId < 0)
        {
            progressInfo.Report(string.Format("Not registered. {0}", RegisteredUserId));
        }
        else
        {
            progressInfo.Report(string.Format("Updating user {0} info...", RegisteredUserId));
            progressInfo.Report("Registered. Id: " + RegisteredUserId);
        }
    }
    catch (Exception ex)
    {
        progressInfo.Report("Connection error");
        if (ThrowExceptions)
            throw ex;
    }
}

public async Task<int> UpdateProgramUsageAsync()
{
    try
    {
        using (var client = new HttpClient())
        {
            client.BaseAddress = ApiUri;
            client.DefaultRequestHeaders.Accept.Clear();
            HttpResponseMessage response = await client.GetAsync(string.Format("api/update/{0}/{1}/{2}/", RegisteredUserId, ProgramName, ProgramVersion));
            return response.IsSuccessStatusCode
                ? Convert.ToInt32(response.Content.ReadAsStringAsync().Result)
                : -1;
        }
    }
    catch (Exception)
    {
        if (ThrowExceptions)
            throw;
        else
            return -666;
    }
}

private const string ConnectionString = "allthestuffsensitivetoconnecttodatabase";
[Route("api/getid/{username}")]
public async Task<int> GetIdAsync(string username)
{
    using (var conn = new SqlConnection(ConnectionString))
    {
        conn.Open();
        if (conn.State == ConnectionState.Open)
        {
            var result = await ExecuteScalarCommandAsync(GetRegisteredUserByName, conn,
                new[]
                    {
                        new SqlParameter(UserNameCol, username), 
                    });
            if (result != null && !(result is DBNull))
            {
                return Convert.ToInt32(result);
            }
            return 0;
        }
    }
    return -1;
}

private async Task<object> ExecuteScalarCommandAsync(string commandName, SqlConnection conn, SqlParameter[] parameters)
{
    using (var command = new SqlCommand(commandName, conn)
    {
        CommandType = CommandType.StoredProcedure,
    })
    {
        command.Parameters.AddRange(parameters);
        return await command.ExecuteScalarAsync();
    }
}

[Route("api/update/{userid}/{programname}/{version}")]
[AcceptVerbs("GET")]
public async Task<int> UpdateProgramUsageAsync(string userid, string programname, string version)
{
    using (var conn = new SqlConnection(ConnectionString))
    {
        conn.Open();
        if (conn.State == ConnectionState.Open)
        {
            var result = await ExecuteScalarCommandAsync(UpdateProgramUsage, conn,
        new[]
            {
                new SqlParameter(UserIdCol, userid), 
                new SqlParameter(ProgramNameCol, programname), 
                new SqlParameter(VersionCol, version)
            }
        );
            if (result != null && !(result is DBNull))
            {
                return Convert.ToInt32(result);
            }
        }
    }
    return 0;
}