Simple and reusable system for user registration and tracking and auto-updates - follow-up

Question

This is a follow up question of this one.

Since the original question was posted, it has turned out that in some cases I want the code to be synchronous and in others to be async. I have updated the code the 'handle registration' method is now fully sync I believe:

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

Since that I have also created a 'handle updates' logic (which is more or less identical). Method returns true if new version is available and false if it is not.

 public bool HandleUpdates(IProgress<string> progressInfo = null)
    {
        return Task.Run((() => HandleUpdatesAsync(progressInfo))).Result;
    }

And I have made their async counterparts public as well.

Now, when I am using the code, and I want to block the main thread, I use simply updateHelper.HandleUpdates(prog);. This blocks the thread pretty well. However, I am not sure about the following - what is the difference between:

Task.Run(() => regHelp.HandleRegistration(progressInfo1)); //appears to not block the thread
Task.Run(() => regHelp.HandleRegistrationAsync(progressInfo1)); //appears to not block the thread
regHelp.HandleRegistrationAsync(prog0); //without 'await', appears to block the thread, but not 'fully'

Also, I believe that I could only use await regHelp.HandleRegistrationAsync(prog0); in an async method. If I am using it for example in the constructor (e.g. public MainWindow() or in static void Main(string[] args)), the proper way would be to use Task.Run(); for it?

As for other changes, I have replaced const value for connString in my app with a connection string settings from Azure. As for naming of instances of RegistrationHelper, I will keep that in mind - though in my non-English head it sounds pretty good. It's only used once per app in two lines of code anyways.

As for the security, I have already introduced something very basic a couple of weeks ago.

I am sending a little string (a 'password' let's say) along with the HTTP request. And at the beginning of each API method I check if the 'password' provided is correct. If not, then return with an error code.

 [Route("api/getver/{programname}")]
    public async Task<string> GetLatestVersionNumberAsync(string programname)
    {
        if (!BasicAuthProvider.PerformBasicAuthentication(this.Request))
        {
            return "-960";
        }
        //rest of code 
    }
public static class BasicAuthProvider
{
    private static string BasicAuthenticationKey
{
    get { return ConfigurationManager.ConnectionStrings["BasicAuthenticationKey"].ConnectionString; }
    //I keep it as connection string because it's not 'visible' by default in manage interface of Azure, though I suppose it's //a litte difference if any
}

public static bool PerformBasicAuthentication(HttpRequestMessage message)
{
    var authorization = message.Headers.Authorization;
    var decodedHeader = System.Text.Encoding.ASCII.GetString(Convert.FromBase64String(authorization.Parameter));
    if (decodedHeader.Equals(BasicAuthenticationKey))
    {
        return true;
    }
    return false;
}
}

Now, as for the HttpPost, I have handled it as follows:

For the data that I want to post, I have created a class in my UserController:

public class UserInfo
        {
            public string Email { get; set; }
            public string UserName { get; set; }
            public string MachineName { get; set; }
        }

Then, the action is as follows:

 [Route("registerbyemail")]
        [HttpPost]
        public async Task<int> RegisterUserByEmailAsync(UserInfo info)
        {
            if (!string.IsNullOrEmpty(info.Email) && !string.IsNullOrEmpty(info.UserName) && !string.IsNullOrEmpty(info.MachineName))
            {
                return await RegisterUserEmailAsync(info.Email, info.UserName, info.MachineName);
            }
            else
            {
                return (int)(ResultCodes.Post | ResultCodes.IncorrectInputParameters | ResultCodes.RegisterUser);
            }
        }

And the generic extension method that calls it is:

internal static async Task<string> SendPostMessageAsync(Uri apiUri, string action, Dictionary<string, string> values, bool throwExceptions)
        {
            try
            {
                using (var client = new HttpClient())
                {
                    client.BaseAddress = apiUri;
                    client.DefaultRequestHeaders.Accept.Clear();
                    var byteArray = Encoding.ASCII.GetBytes(ApiHelper.DefaultApiCreds);
                    client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));

                    var content = new FormUrlEncodedContent(values);

                    HttpResponseMessage response = await client.PostAsync(action, content);
                    return response.IsSuccessStatusCode
                        ? response.Content.ReadAsStringAsync().Result
                        : string.Format("-{0}", Bj.ConcatInts(100, (int)response.StatusCode));

                }
            }
            catch (Exception)
            {
             //handle it
            }
        }

Answer 1

if (decodedHeader.Equals(BasicAuthenticationKey))
{
    return true;
}
return false;

Whenever you've got something like this, you can just directly return the result to simplify the code:

return decodedHeader.Equals(BasicAuthenticationKey);