Blog (pg. 12)

I had this problem recently in Visual Studio that drove me mad! It was a VB ASP.NET web project and Intellisense would not work on ASPX pages, complaining about the asp tag prefix. There is a lot of documented bugs/fixes for this online (google it), including deleting the solution .suo file, clearing out bin/obj files, deleting the visual studio reflected schemas files (under the app data folder), clearing your VS settings. I tried them all but to no avail.. My problem though, was quite different in 2 ways.. Firstly my project was building and running absolutely fine (not sure about this for the other people's problems, but maybe worth noting). Also, in my opinion, the cause of my problem was the way I had set up the project to re-use an existing web projects files and code (I was re-using quite a lot of code files from another project by adding them as linked files for the code-infront and a DLL reference for the code behind.) I have had some problems with VB project in the past due to this kind of thing, because VB does not define the root namespace in the code files it has caused some issues, which led me to believe the problem was being caused by the vbproj settings. I remembered that by default I have option strict set to "on" for VB projects, since the project was building but the designer was just being "whingy" I decided to turn option strict off... It worked! :)

Often applications allow a user to specify inputs by providing the IDs, or unique names of items which can be found in the database. Using the user provided collection of items, you would query your data and hopefully return a collection with the same number of elements as what the user was searching for. In some cases though, not all the items the user provided will be found in the database. I recently wrote a generic helper method which provides warnings to the user for any "missing" elements (i.e. they asked for it in the source but it wasn't in the output).

public static class MissingItemsHelper
    {
        /// <summary>
        /// Will display a message to the user showing any items that existing in the itemsToFind collection that did not exist in the collectionToSearch (using the Equals operator)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="itemsToFind">The collection containing the items which need to be checked against the other list</param>
        /// <param name="collectionToSearch">The collection which will be checked for the existance of each item</param>
        /// <param name="missingItemMessageTextSelector">For items that are missing, this selector function should return the text you want to output in the message for each item</param>
        /// <param name="messageNounText">The singular noun which identifies what you are currently searching</param>
        public static string GetWarningsIfItemsNotInCollection<T>(
            IEnumerable<T> itemsToFind,
            IEnumerable<T> collectionToSearch,
            Func<T, string> missingItemMessageTextSelector,
            string messageNounText)
        {
            //any missing items? - find those which dont have an equal in the target list
            IEnumerable<T> missingItems =
                (from sourceItem in itemsToFind
                 where collectionToSearch.Any((f) => f.Equals(sourceItem)) == false
                 select sourceItem);

            //if there were some missing items, show the message to the user with the missing items text
            if (missingItems.Count() > 0)
                    return string.Format("The following {0}s were not found:\r\n", messageNounText)
                                    + string.Join("\r\n",missingItems.Select(missingItemMessageTextSelector).ToArray());

            return string.Empty;
        }
    }

I've tried to keep it as generic as possible, which is why you must provide the type T of the elements and a function which selects the "missing" information as well as a noun which describes that information. For example:

MissingItemsHelper.GetWarningsIfItemsNotInCollection<long>(
                    inputIds, (from d in dataItems select d.UniqueId),
                    new Func<long, string>((id) => id.ToString()), "Unique ID");

This could be extended further to take various types with a comparison operator, but for simplicity I have kept to one type.

Using Silverlight and MVVM you often use property change tracking mechanisms, such as implementing INotifyPropertyChanged and using ObservableCollections (which implement INotifyCollectionChanged). This is fine when you are only interested in letting the UI synchronise with your data in the ViewModel (and vice-versa) but sometimes you need to track these changes in the code, either within your own class or in another class elsewhere. I had this issue recently, where I needed to know in my "Results" ViewModel when anything changed in any of my various "Input" ViewModels so that I could invalidate the results (so the user knows they need to re-calculate). In order to achieve this I needed to listen to events in the following 3 categories on many properties:

• Property changed (setter called)
• Collection changed (items added/removed)
• Collection item property changed (element of a list has a property changed)

Rather than having to write event handling code and logic everywhere, I decided to design a base class that my "Input" viewmodels can inherit from that would take care of rolling up these 3 scenarios into a single event. In my "Results" class I then can simply add a listener for the one "InputsChanged" event. My view model base derives from a base implementing INotifyPropertyChanged and looks as follows:

public abstract class ResultsInputViewModelBase : ViewModelBase
    {
        /// <summary>
        /// A list of tracked properties that implement INotifyCollectionChanged, therefore need the CollectionChanged tracking
        /// </summary>
        private Dictionary<string, PropertyInfo> _collectionChangingPropertiesToTrack = new Dictionary<string, PropertyInfo>();

        /// <summary>
        /// A list of tracked properties that implement IEnumerable, therefore may need the items tracking
        /// </summary>
        private Dictionary<string, PropertyInfo> _enumerablePropertiesToTrack = new Dictionary<string, PropertyInfo>();

        /// <summary>
        /// Initializes a new instance of the <see cref="ResultsInputViewModelBase" /> class. In the base constructor we setup the auto-tracking feature, which attaches to PropertyChangedEvent and prepares for tracking CollectionChanged and sub-items PropertyChanged events
        /// </summary>
        public ResultsInputViewModelBase()
        {
            // subscribe the property changed event for this instance
            this.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(this.ResultsInputViewModelBase_PropertyChanged);

            // look for properties that implement INotifyCollectionChanged (observable collections) in the tracked properties so we can auto-track these aswel
            foreach (string propertyName in this.TrackedInputProperties)
            {
                object currentValue = this;

                // find the property info using reflection
                if (!string.IsNullOrWhiteSpace(propertyName))
                {
                    PropertyInfo pi = null;

                    // nested property?
                    if (propertyName.Contains("."))
                    {
                        // child property - iterate the tree
                        Type currentType = this.GetType();

                        string[] props = propertyName.Split('.');
                        int pc = 0;
                        foreach (string p in props)
                        {
                            pc++;
                            pi = currentType.GetProperty(p);
                            if (pi != null && pc < props.Length)
                            {
                                currentType = pi.PropertyType;
                                currentValue = pi.GetValue(currentValue, null);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                    else
                    {
                        // direct property
                        pi = this.GetType().GetProperty(propertyName);
                    }

                    if (pi != null)
                    {
                        // does this property implement INotifyCollectionChanged?
                        if (typeof(INotifyCollectionChanged).IsAssignableFrom(pi.PropertyType))
                        {
                            // add the PropertyInfo to the list of tracked collections, so we can attach when the value != null
                            this._collectionChangingPropertiesToTrack.Add(propertyName, pi);

                            // incase its already != null, we can attempt to attach now
                            this.TryAttachCollectionTracker(pi, currentValue);
                        }

                        // does this property implement IEnumerable?
                        if (typeof(IEnumerable).IsAssignableFrom(pi.PropertyType))
                        {
                            // add the PropertyInfo to the list of tracked collections, so we can attach when the value != null
                            this._enumerablePropertiesToTrack.Add(propertyName, pi);

                            // incase its already != null, we can attempt to attach now
                            this.TryAttachEnumeratedPropertyChangeTracker(pi, currentValue);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Event is fired whenever a tracked property or collection is changed in the derived class
        /// </summary>
        public event EventHandler InputsChanged;

        /// <summary>
        /// Gets the properties that are tracked in this base class. Implement in a derived class to signal each property which needs to raise the InputsChanged event
        /// </summary>
        protected abstract string[] TrackedInputProperties
        {
            get;
        }

        /// <summary>
        /// Provides a way for derived classes to inform that something in their inputs that requires a re-calculation has changed,
        /// although they shouldn't need to call this manually - put the property name in the TrackedInputProperties instead
        /// </summary>
        protected void OnInputsChanged()
        {
            if (this.InputsChanged != null)
            {
                this.InputsChanged(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// Attempts to get the value of a property that implements INotifyCollectionChanged, if the value is non-null, attaches to the CollectionChanged event
        /// </summary>
        /// <param name="pi">Property Info instance of the target property</param>
        /// <param name="container">The object containing the collection property</param>
        private void TryAttachCollectionTracker(PropertyInfo pi, object container)
        {
            // read the value of the property for the current instance
            INotifyCollectionChanged collection_propValue = pi.GetValue(container, null) as INotifyCollectionChanged;

            // if the property has a value, we can attach to its CollectionChanged event
            if (collection_propValue != null)
            {
                collection_propValue.CollectionChanged += new NotifyCollectionChangedEventHandler(this.ResultsInputViewModelBase_CollectionChanged);
            }
        }

        /// <summary>
        /// Attempts to get the value of a property that implements IEnumerable, if the value is non-null, attaches to the child elements PropertyChanged event (if implemented)
        /// </summary>
        /// <param name="pi">Property Info instance of the target property</param>
        /// <param name="container">The object containing the enumerable property</param>
        private void TryAttachEnumeratedPropertyChangeTracker(PropertyInfo pi, object container)
        {
            // read the value of the property for the current instance
            IEnumerable collection_propValue = pi.GetValue(container, null) as IEnumerable;

            // if the property has a value, we can attach to its CollectionChanged event
            if (collection_propValue != null)
            {
                foreach (var element in collection_propValue)
                {
                    if (element is ResultsInputViewModelBase)
                    {
                        ((ResultsInputViewModelBase)element).InputsChanged += this.InputsChanged;
                    }
                    else if (element is INotifyPropertyChanged)
                    {
                        ((INotifyPropertyChanged)element).PropertyChanged += new PropertyChangedEventHandler(this.ResultsInputViewModelBase_TrackedElementPropertyChanged);
                    }
                }
            }
        }

        /// <summary>
        /// Fires when any property that raises PropertyChanged event is called in the derived class
        /// </summary>
        /// <param name="sender">Object raising the event</param>
        /// <param name="e">Event arguments</param>
        private void ResultsInputViewModelBase_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            // if the property that has raised the event is one of our tracked properties, we can apply further processing logic
            if (Array.IndexOf(this.TrackedInputProperties, e.PropertyName) >= 0)
            {
                object currentValue = this;

                // find the property info using reflection
                if (!string.IsNullOrWhiteSpace(e.PropertyName))
                {
                    PropertyInfo pi = null;

                    // nested property?
                    if (e.PropertyName.Contains("."))
                    {
                        // child property - iterate the tree
                        Type currentType = this.GetType();

                        string[] props = e.PropertyName.Split('.');
                        int pc = 0;
                        foreach (string p in props)
                        {
                            pc++;
                            pi = currentType.GetProperty(p);
                            if (pi != null && pc < props.Length)
                            {
                                currentType = pi.PropertyType;
                                currentValue = pi.GetValue(currentValue, null);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }

                // if the value of a changeable collection has just been set, we need to (re-)attach our collection tracker
                if (this._collectionChangingPropertiesToTrack.ContainsKey(e.PropertyName))
                {
                    this.TryAttachCollectionTracker(this._collectionChangingPropertiesToTrack[e.PropertyName], currentValue);
                }

                // if the value of a enumerable has just been set, we need to (re-)attach our collection tracker
                if (this._enumerablePropertiesToTrack.ContainsKey(e.PropertyName))
                {
                    this.TryAttachEnumeratedPropertyChangeTracker(this._enumerablePropertiesToTrack[e.PropertyName], currentValue);
                }

                this.OnInputsChanged();
            }
        }

        /// <summary>
        /// Fires when any property of an element of a collection that is being tracked is fired
        /// </summary>
        /// <param name="sender">Object raising the event</param>
        /// <param name="e">Event arguments</param>
        private void ResultsInputViewModelBase_TrackedElementPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            this.OnInputsChanged();
        }

        /// <summary>
        /// Fires when a collection of a tracked property changes
        /// </summary>
        /// <param name="sender">Object raising the event</param>
        /// <param name="e">Event arguments</param>
        private void ResultsInputViewModelBase_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            // we need to attach the property changed etc of the new items
            if (e.NewItems != null)
            {
                foreach (var element in e.NewItems)
                {
                    if (element is ResultsInputViewModelBase)
                    {
                        ((ResultsInputViewModelBase)element).InputsChanged += this.InputsChanged;
                    }
                    else if (element is INotifyPropertyChanged)
                    {
                        ((INotifyPropertyChanged)element).PropertyChanged += new PropertyChangedEventHandler(this.ResultsInputViewModelBase_TrackedElementPropertyChanged);
                    }
                }
            }

            // we should stop tracking the items leaving the collection
            if (e.OldItems != null)
            {
                foreach (var element in e.OldItems)
                {
                    if (element is ResultsInputViewModelBase)
                    {
                        ((ResultsInputViewModelBase)element).InputsChanged -= this.InputsChanged;
                    }
                    else if (element is INotifyPropertyChanged)
                    {
                        ((INotifyPropertyChanged)element).PropertyChanged -= new PropertyChangedEventHandler(this.ResultsInputViewModelBase_TrackedElementPropertyChanged);
                    }
                }
            }

            this.OnInputsChanged();
        }
    }

This class essentially adds internal listeners to all the different kinds of events that the derived class may raise that we are interested in. It leaves one single property that must be implemented in the derived class, where the programmer can list the properties which should be tracked. For example:

protected override string[] TrackedInputProperties
        {
            get { return new string[] {
                "AgeBandFilters",
                "MaritalStatusFilters"
            }; }
        }

Finally, in the "Results" ViewModel, I pass in an instance of my derived class and then listen for the "InputsChanged" event:

public ExampleInputViewModel ExampleInputViewModel
        {
            get { return _exampleInputViewModel; }
            set {
                //track changes in input configs to invalidate results
                RemoveInputChangedHandler(_exampleInputViewModel);
                _exampleInputViewModel = value;
                AddInputChangedHandler(_exampleInputViewModel);

                RaisePropertyChanged("ExampleInputViewModel"); }
        }

 private void RemoveInputChangedHandler(ResultsInputViewModelBase inputConfigViewModel)
        {
            if(inputConfigViewModel != null)
                inputConfigViewModel.InputsChanged -= new EventHandler(inputConfigViewModel_InputsChanged);
        }

        private void AddInputChangedHandler(ResultsInputViewModelBase inputConfigViewModel)
        {
            if (inputConfigViewModel != null)
                inputConfigViewModel.InputsChanged += new EventHandler(inputConfigViewModel_InputsChanged);
        }

        void inputConfigViewModel_InputsChanged(object sender, EventArgs e)
        {
                //invalidate results
                CurrentResults = null;
        }

In SQL Server Management Studio the default setting for Query Execution 'ARITHABORT' setting is ON. In ADO.NET the default setting is OFF. This can cause problems when trying to optimise your slow running queries, as the execution plans used by .NET and SSMS can be different. This can result in different execution times of your RPC completed vs SP completed in SQL Profiler. Also, it can cause your ADO.NET based queries to run slower, if the plan was optimised for the SSMS based query. In order to avoid this problem, I would recommend setting the option to OFF in SSMS: Tools > Options > Query Execution > SQL Server > Advanced.. Also, if you have come across this problem, after having changed the setting it may be worth clearing your plan cache:

DBCC FREEPROCCACHE

Following on from my chunked file uploader, I needed a way to initiate a server side import of a file and track the progress on the Silverlight clientside. To do this, I first wrote my import logic which was to be performed on the server. The important factor with the import logic, is that it raises an event whenever a line of data has been imported. I then wrote a WCF service wrapper for this, which uses a separate thread to perform the import so that the service call can return immediately after having started the import. The service comprises of 3 functions to; begin the import, check the progress, get the results. The service interface and implementation are shown below:

[ServiceContract]
    public interface IExampleImporter
    {
       
        [OperationContract]
        void BeginImportUploadedExampleFile(string uploadedFilename, bool hasHeaderRow);

        [OperationContract]
        bool CheckImportUploadedExampleFileComplete(string uploadFilename, out int rowsImported);

        [OperationContract]
        Response<ImportResult> GetImportUploadedExampleFileResults(string uploadFilename);

    }

public partial class ImportService : IExampleImporter
    {
        //create some static dictionaries for tracking the import progress and results across service calls
        private static Dictionary<string, int> _fileRowsImported = new Dictionary<string,int>();
        private static Dictionary<string, Response<ImportResult>> _fileResults = new Dictionary<string, Response<ImportResult>>();

        //we will need a class to define the params to the import thread
        private class ImportUploadedExampleFileThreadParams
        {
            public HttpContext HttpContext { get; set; }

            public string UploadFileToken { get; set; }
            public bool HasHeaderRow { get; set; }
        }
               
        //this is the service endpoint to begin a new import
        public void BeginImportUploadedExampleFile(string uploadFileToken, bool hasHeaderRow)
        {
            //you can only import a file which isnt already being imported
            if (_fileResults.ContainsKey(uploadFileToken) || _fileRowsImported.ContainsKey(uploadFileToken))
                throw new Exception("This file is already being imported");

            //initialise a place in the rows imported list
            _fileRowsImported.Add(uploadFileToken, 0);

            //we will run the import in another thread to avoid service timeouts - client can then poll 'IsUploadComplete'
            System.Threading.Thread importThread = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(ImportUploadedExampleFileThreadEntry));
            importThread.IsBackground = true;

            importThread.Start(new ImportUploadedExampleFileThreadParams()
            {
                HttpContext = HttpContext.Current,
                
                UploadFileToken = uploadFileToken,
                HasHeaderRow = hasHeaderRow
                
            });

        }

        public bool CheckImportUploadedExampleFileComplete(string uploadFileToken, out int rowsImported)
        {
            //does this import exist?
            lock (_fileRowsImported)
            {
                if (!_fileRowsImported.ContainsKey(uploadFileToken))
                    throw new Exception("No current import found for the given token");

                rowsImported = _fileRowsImported[uploadFileToken];
            }

            //is it complete?
            return _fileResults.ContainsKey(uploadFileToken);
            
        }

        public Response<ImportResult> GetImportUploadedExampleFileResults(string uploadFileToken)
        {
            Response<ImportResult> res;

            //does this import exist and complete?
            lock (_fileResults)
            {
                if (!_fileResults.ContainsKey(uploadFileToken))
                    throw new Exception("Import with given token does not exist or was not yet complete");

                res = _fileResults[uploadFileToken];
                
                //now remove the result
                _fileResults.Remove(uploadFileToken);
            }

            //also remove the progress since this import is now done
            lock (_fileRowsImported)
            {
                _fileRowsImported.Remove(uploadFileToken);
            }

            return res;
        }

        private void ImportUploadedExampleFileThreadEntry(object threadParam)
        {
            //parse the thread params
            ImportUploadedExampleFileThreadParams p = (ImportUploadedExampleFileThreadParams)threadParam;

            Response<ImportResult> importResponse = new Response<ImportResult>();

            //ensure the file exists
            string fullFilePath = p.HttpContext.Server.MapPath("UploadFiles\\" + p.UploadFileToken);

            if (System.IO.File.Exists(fullFilePath))
            {
                 //create an instance of the import helper to perform the import
                 ExampleImporterHelper helper = new ExampleImporterHelper();
                 helper.RowImported += new Action<string, bool>(helper_RowImported);

                 //invoke the importer and get the result
                 importResponse.Item = helper.Import(fullFilePath, p.HasHeaderRow);
                 importResponse.IsSuccess = true;

            }
            else
            {
                importResponse.IsSuccess = false;
                importResponse.MessageKey = "File not found";
            }

            lock (_fileResults)
            {
                _fileResults.Add(p.UploadFileToken, importResponse);
            }
        }

        void helper_RowImported(string filename, bool successfulRow)
        {
            //parse the token from the filename
            string token = System.IO.Path.GetFileName(filename);

            //update the rows imported
            lock (_fileRowsImported)
            {
                if (_fileRowsImported.ContainsKey(token))
                    _fileRowsImported[token] += 1;
            }

        }

    }

The way this works is, after having uploaded a file to the server, the client calls 'BeginImport..' passing the filename/token which initiates the import. The service creates a new thread which runs the actual import code passing in the required parameters. The service maintains two Dictionaries, one which stores the current number of lines imported by filename (by counting the RowImported events) and one which stores the eventual 'ImportResult' - which exists once the import is complete. Calling the 'is complete' function will return true or false and additionally will return the number of lines imported through the 'out' parameter. This enables the client to determine if an upload has finished and if not, how many lines are complete so far - which can be reflected in the UI based on the total number of lines. My particular example relies on the following data contracts to transmit the results:

[DataContract]
    public class ImportResult
    {
        [DataMember]
        public int SuccessCount { get; set; }

        [DataMember]
        public int FailCount { get; set; }

        private List<ImportException> _Exceptions = new List<ImportException>();

        [DataMember]
        public List<ImportException> Exceptions
        {
            get { return _Exceptions; }
            set { _Exceptions = value; }
        }


    }
    [DataContract]
    public class ImportException
    {
        [DataMember]
        public int LineNumber { get; set; }

        public Exception Exception { get; set; }

        [DataMember]
        public string ErrorMessage
        {
            get
            {
                return Exception.Message;
            }
            private set { }
        }

        public ImportException(int lineNumber, Exception ex)
        {
            this.LineNumber = lineNumber;
            this.Exception = ex;
        }
    }

An example of calling the service in Silverlight (using MVVM viewmodel) is as follows:

public void ImportUploadedFile(string serverToken)
        {

            ImportProgressText = string.Format("[{0}] Starting Import. (this may take a while)\r\n", DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));

            //in part 4 we actually import the file and get the results of the import
            IsImporting = true;

            //Start the Example importer
            ServiceInerfaceClient svc = ServiceUtility.GetExampleClient();
            svc.BeginImportUploadedExampleFileCompleted += new EventHandler<AsyncCompletedEventArgs>(svc_BeginImportUploadedExampleFileCompleted);
            svc.BeginImportUploadedExampleFileAsync(serverToken, HasHeaderRow);
        }

        void svc_BeginImportUploadedExampleFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            ((ServiceInerfaceClient)sender).BeginImportUploadedExampleFileCompleted -= svc_BeginImportUploadedExampleFileCompleted;

            //check no errors launching import
            if (e.Error == null)
            {
                //now that the import has successfully started we can begin polling for the results
                PollForImportResults();
            }
            else
            {
                IsImporting = false;
                ShowBusy(false);

                if (e.Error != null)
                    ImportProgressText += string.Format("[{0}] ERROR: " + e.Error.Message, System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
                else
                    ImportProgressText += string.Format("[{0}] ERROR: Unknown Error Importing File", System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
            }
        }

        private void PollForImportResults()
        {
            //set up a client and the event handler
            ServiceInerfaceClient svc = ServiceUtility.GetExampleClient();
            svc.CheckImportUploadedExampleFileCompleteCompleted += new EventHandler<CheckImportUploadedExampleFileCompleteCompletedEventArgs>(svc_CheckImportUploadedExampleFileCompleteCompleted);

            //start the recursion on another thread (prevent freezing the UI)
            System.Threading.Thread pollThread = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(PollForImportResults_Recursion));
            pollThread.IsBackground = true;
            pollThread.Start(svc);

        }

        private void PollForImportResults_Recursion(object ServiceInerfaceClientInstance)
        {
            //wait 5 secs
            System.Threading.Thread.Sleep(5000);

            //call the service and wait for the poll result
            ServiceInerfaceClient svc = (ServiceInerfaceClient)ServiceInerfaceClientInstance;
            svc.CheckImportUploadedExampleFileCompleteAsync(SelectedFile.ServerToken);
        }

        void svc_CheckImportUploadedExampleFileCompleteCompleted(object sender, CheckImportUploadedExampleFileCompleteCompletedEventArgs e)
        {
            //make sure no errors reading polling service
            if (e.Error == null)
            {
                //update the rows imported counter
                //update the UI via the dispatcher thread
                Deployment.Current.Dispatcher.BeginInvoke(new Action<ExampleAdminViewModel>((vm) =>
                    {
                        vm.RowsProcessed = e.rowsImported;
                    }), this);

                //was the import complete?
                if (e.Result == true)
                {
                    //my job now done, remove the handler
                    ((ServiceInerfaceClient)sender).CheckImportUploadedExampleFileCompleteCompleted -= svc_CheckImportUploadedExampleFileCompleteCompleted;

                    //update the UI via the dispatcher thread
                    Deployment.Current.Dispatcher.BeginInvoke(new Action<ExampleAdminViewModel>((vm) =>
                        {
                            vm.ImportProgressText += string.Format("[{0}] Import Complete, retreiving results.\r\n", System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
                        }), this);

                    //finish the import to get the results
                    GetImportResults();
                }
                else
                {
                    //still not finished, continue with the recursion
                    PollForImportResults_Recursion((ServiceInerfaceClient)sender);
                }
            }
            else
            {
                //display errors using dispatcher (UI) thread
                Deployment.Current.Dispatcher.BeginInvoke(new Action<ExampleAdminViewModel, CheckImportUploadedExampleFileCompleteCompletedEventArgs>((vm, UIe) =>
                {
                    vm.IsImporting = false;
                    vm.ShowBusy(false);

                    if (UIe.Error != null)
                        vm.ImportProgressText += string.Format("[{0}] ERROR: " + UIe.Error.Message, System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
                    else
                        vm.ImportProgressText += string.Format("[{0}] ERROR: Unknown Error Importing File", System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
                }), this, e);
               
            }
        }

        private void GetImportResults()
        {
            ServiceInerfaceClient svc = ServiceUtility.GetExampleClient();

            svc.GetImportUploadedExampleFileResultsCompleted += new EventHandler<GetImportUploadedExampleFileResultsCompletedEventArgs>(svc_GetImportUploadedExampleFileResultsCompleted);
            svc.GetImportUploadedExampleFileResultsAsync(SelectedFile.ServerToken);
        }

        void svc_GetImportUploadedExampleFileResultsCompleted(object sender, GetImportUploadedExampleFileResultsCompletedEventArgs e)
        {
            
            if (e.Error == null && e.Result != null && e.Result.IsSuccess)
            {
                ImportResult res = e.Result.Item;

                //file has finished importing, calculate a string to represent the results
                string importResultsText = string.Format(@"[{0}] Results:

----------------------------------------
Successful rows: {1}
Failed rows: {2}

Failure breakdown:
---------------------------------------

",
                                System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"),
                                res.SuccessCount,
                                res.FailCount);

                foreach (ImportException iEx in res.Exceptions)
                {
                    importResultsText += string.Format("Line: {0} - {1}\r\n", iEx.LineNumber, iEx.ErrorMessage);
                }

                //display results using dispatcher (UI) thread
                Deployment.Current.Dispatcher.BeginInvoke(new Action<ExampleAdminViewModel>((vm) =>
                {
                    vm.ImportProgressText += importResultsText;
                    vm.IsImporting = false;
                    vm.ShowBusy(false);
                }), this);
            }
            else
            {

                //display errors using dispatcher (UI) thread
                Deployment.Current.Dispatcher.BeginInvoke(new Action<ExampleAdminViewModel, GetImportUploadedExampleFileResultsCompletedEventArgs>((vm, UIe) =>
                {
                    vm.IsImporting = false;
                    vm.ShowBusy(false);

                    if (UIe.Result != null)
                        vm.ImportProgressText += string.Format("[{0}] ERROR: " + UIe.Result.MessageKey, System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
                    else if (UIe.Error != null)
                        vm.ImportProgressText += string.Format("[{0}] ERROR: " + UIe.Error.Message, System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
                    else
                        vm.ImportProgressText += string.Format("[{0}] ERROR: Unknown Error Importing File", System.DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
                }), this, e);

               
            }

        }

This is again using threads to perform the polling of the server so that calls to Thread.Sleep can be made on the polling thread without freezing the UI. I have used 'BeginInvoke' on the 'Dispatcher' thread when setting ViewModel properties, as this indirectly updates the UI (through the bindings) and so must take place on the main UI thread.