Question

Just getting my head around WCF, so forgive me for the inelegant coding.
The issue I’m having is I seem to be submitting data twice to my service (see screenshot), even though (I think) I’m only doing it once.
Could someone please let me know what I might be doing wrong? Or even just suggest a better way to do it if I’m doing it inefficiently.

Code follows:

public void EndOfLevel()
    {
        GlobalVariable.TotalQuestionsAsked = 10;
        GlobalVariable.CorrectDecimal = GlobalVariable.Correct / GlobalVariable.TotalQuestionsAsked;

        //Show loading screen
        UploadingScreen.Visibility = Visibility.Visible;
        //Submit this levels results.

        Service1Client client = null;
        client = new Service1Client();

            //Gather the results and details
            Result thislevel = new Result();
            thislevel.Datetime = DateTime.Now;
            thislevel.result = GlobalVariable.CorrectDecimal;
            thislevel.TimesTable = GlobalVariable.NeedsHelpWith;

            //submit them
            try
            {
                client.SubmitResultAsync(thislevel);
            }
            catch
            {
                MessageBox.Show("Error uploading data");
            }
            finally
            {
                client.Close();
                Results r3 = new Results();
                this.NavigationService.Navigate(r3);
            }



    }

WCF Test Client:

Cheers,
Nick

Answer 1

If I may, here’s a pattern for managing our asynchronous calls between our WPF applications and our WCF Services.

In this section we have a public accessor to our service client that ensures that the connection to the client is open prior to calling a service method:

public static MyServiceClient Client
{
    get
    {
        return GetMyServiceClient();
    }
}
private static MyServiceClient client;

private static MyService.MyServiceClient GetMyServiceClient()
{
    VerifyClientConnection();

    return client;
}

private static void VerifyClientConnection()
{
    if (client == null || client.State == System.ServiceModel.CommunicationState.Closed)
    {
        client = new MyService.MyServiceClient();
    }
}

And in this section is an example of our asynchronous call and callback pattern (this example shows the delegate and callback we’re using for passing exception data to our service):

public delegate void LogExceptionCompletedEvent();
public static LogExceptionCompletedEvent LogExceptionCompleted;

public static void LogExceptionAsync(SilverlightException exception)
{
    string json = JsonConvert.SerializeObject(exception);

    Client.LogExceptionCompleted -= client_LogExceptionCompleted;
    Client.LogExceptionCompleted += client_LogExceptionCompleted;
    Client.LogExceptionAsync(json);
}

private static void client_LogExceptionCompleted(object sender, AsyncCompletedEventArgs e)
{
    if (LogExceptionCompleted != null)
    {
        LogExceptionCompleted();
    }
}

In this example, a view model could attach an event handler to the LogExceptionCompleted delegate and in turn receive the result of the callback when it returns from the service.

We basically repeat this pattern for the asynchronous WCF service calls we need to make from our application and it keeps them very organized as well as unit testable.