Nested Asynchronous function in Silverlight

Question

I am trying to call a nested Asynchronous function but I am not getting the required data. Since I am using a wcf service with Silverlight I can only use Asynchronous functions.

In my code I am saving a set of rows containing userdata. Before I save it I need to check the username is unique. Now I only need to find out the first one and then break out of loop and show a message to the user.for simplicity sake, I have stripped the function of all the extra data and this is how it looks

      private void SaveUsers(bool CloseForm)
            {
                ObservableCollection<User> _UpdatedUsers = new ObservableCollection<User>(); 
                DatabaseServiceLocal _dataService = new DatabaseServiceLocal(Database);

                foreach (UserViewModel _User in _AllUsers)
                {
                    //bool success = _dataService.IsUserNameUnique(_User.UserName, _User.UserID, Database.CurrentClient.ClientID);
                    if (_User.Dirty && !_User.IsBlank)
                    {                     
                        _dataService.CheckIsUserNameUnique += (s, e) =>
                        {
                            if (e.IsUnique)
                                _UpdatedUsers.Add(_User.SaveAsUser());
                            else
                              {
                                _UpdatedUsers = new ObservableCollection<User>();
                                csaMessageBox.Show(string.Format("Username {0} is not allowed as it already exists in the system. Please choose a different username.", ""), null);
                                return;
                              }
                        };
                        _dataService.IsUserNameUnique(_User.UserName, _User.UserID, Database.CurrentClient.ClientID);
                    }

                _dataService.UpdateStaffAndUsersCompleted += (s, e) =>
                {
                    BusyIndicator = false;
                    if (e.Success)
                    {
                        }
                        if (CloseForm)
                            ReturnToHomePage();
                        else
                        {

                            LoadUsers();
                            OnUsersSaved();
                        }
                    }

                BusyIndicator = true;
                BusyMessage = "Saving...";
                             _dataService.UpdateUsers(Database.CurrentProject.ProjectID, Database.CurrentClient.ClientID, _UpdatedUsers, _DeletedProjectUsers);
            }

In this case I am trying to find if the username is unique,show user a message and return. Obviously it's not as simple as that.I have tried a couple more different ways but it didn't work. How do I get this working?

Answer 1

Your code would more or less look like this.

ObservableCollection<User> _UpdatedUsers = new ObservableCollection<User>();
int _verifiedUsersCount = 0;
DatabaseServiceLocal _dataService = new DatabaseServiceLocal(Database);

//Verify unique users
private void SaveUsers(bool CloseForm)
{

    _dataService.CheckIsUserNameUnique += CheckIsUserNameUnique;

    foreach (UserViewModel _User in _AllUsers)
    {
        //bool success = _dataService.IsUserNameUnique(_User.UserName, _User.UserID, Database.CurrentClient.ClientID);
        if (_User.Dirty && !_User.IsBlank)
        {
            _dataService.IsUserNameUnique(_User.UserName, _User.UserID, Database.CurrentClient.ClientID);
        }
    }
}

//Store verified users to save
private void CheckIsUserNameUnique(object s, CheckIsUserNameUniqueEventArgs e)
{
    if (e.IsUnique)
        _UpdatedUsers.Add(_User.SaveAsUser());
    else
    {
        csaMessageBox.Show(string.Format("Username {0} is not allowed as it already exists in the system. Please choose a different username.", ""), null);
    }
    verifiedUsersCount++;

    //Call after all the users have been verified for uniqueness
    if (_AllUsers.Count() == verifiedUsersCount)
    {
        OnUniqueUserVerifyComplete();
    }
}

//Save verified users
private void OnUniqueUserVerifyComplete()
{
    //No unique users 
    if (_UpdatedUsers.Count < 1) { return; }

    _dataService.UpdateStaffAndUsersCompleted += (s, e) =>
    {
        BusyIndicator = false;
        if (e.Success)
        {
        }
        if (CloseForm)
            ReturnToHomePage();
        else
        {
            LoadUsers();
            OnUsersSaved();
        }
    };

    BusyIndicator = true;
    BusyMessage = "Saving...";
    _dataService.UpdateUsers(Database.CurrentProject.ProjectID, Database.CurrentClient.ClientID, _UpdatedUsers, _DeletedProjectUsers);
}

Answer 2

I think you can make your life easier by adding a couple of helper functions. The first one is an asynchronous function that checks whether a user is unique. You may need to add some code to set tcs.SetException if there is an error.

private Task<bool> IsUserUniqueAsync(UserViewModel user, DatabaseServiceLocal dataService)
{
    var tcs = new TaskCompletionSource<bool>();

    dataService.CheckIsUserNameUnique += (s, e) =>
                        {
                            tcs.SetResult(e.IsUnique);
                        };
    dataService.IsUserNameUnique(user.UserName, user.UserID, Database.CurrentClient.ClientID);
    return tcs.Task;
}

The second one updates all the users asynchrnously

public Task<bool> UpdateUsersAsync(ObservableCollection<User> updatedUsers, DatabaseServiceLocal dataService)
{
    var tcs = new TaskCompletionSource<bool>();

    BusyIndicator = true;
    BusyMessage = "Saving...";

    dataService.UpdateStaffAndUsersCompleted += (s, e) =>
                {
                    BusyIndicator = false;
                    tcs.SetResult(e.Success);                 
                 };

    dataService.UpdateUsers(Database.CurrentProject.ProjectID, Database.CurrentClient.ClientID, updatedUsers, _DeletedProjectUsers);

    return tcs.Task;
}

Then your SaveUsers method becomes a bit simpler.

private async void SaveUsers(bool CloseForm)
{
    ObservableCollection<User> _UpdatedUsers = new ObservableCollection<User>(); 
    DatabaseServiceLocal _dataService = new DatabaseServiceLocal(Database);
    Dictionary<Task<bool>, User> tasks = new Dictionary<Task<bool>, User>();

    // start all tasks in parallel
    foreach (UserViewModel _User in _AllUsers)
    {
        if (_User.Dirty && !_User.IsBlank)
        { 
            tasks.Add(IsUserUniqueAsync(_User, _dataService), _User);       
        }
    }           

    // process each task as it completes
    while(tasks.Count() > 0 )
    {
        var task = await Task.WhenAny(tasks.Keys.ToArray());

        if(task.Result)
        {
            _UpdatedUsers.Add(_User.SaveAsUser()); 
        }
        else
        {
           MessageBox.Show(string.Format("Username {0} is not allowed as it already exists in the system. Please choose a different username.", ""), null);
           return;
        }

        tasks.Remove(task);
    }

    if( await UpdateUsersAsync(_UpdatedUsers, _dataService))
    {
        if (CloseForm)
            ReturnToHomePage();
        else
        {

            LoadUsers();
            OnUsersSaved();
        }
    }
}