C# Android错误：检测到嵌套信号-报告原始信号

这简直要了我的命。我是android/Xamarin的新手。我在网上找不到任何解释这里发生了什么的东西

我正在使用xamarin表单进行申请。我有一个页面可以将设备与web服务同步

该方法只需从web服务一次检索100条记录，并更新设备上的sqlite表。我随机得到这个错误。我正在为我的测试样本运行5000条记录

点击按钮如下：

 public async void OnSyncCachedData_Clicked(object sender, EventArgs e)
    {
        activityIndicatorAll.IsRunning = true;

        try
        {
            actIndSyncItems.IsRunning = true;
            SyncAllFinished += SynchAllFinishedProcessing;

            await Task.Run(async () => await App.ItemsRepo.LoadCacheDataFromCacheAsync(DbPath).ConfigureAwait(false));

        }
        catch (BAL.Exceptions.NetworkException nex)
        {
            await DisplayAlert(Messages.TitleError, nex.Message, Messages.MsgOk);
        }
        catch (Exception ex)
        {
            await DisplayAlert(Messages.TitleError, string.Format(Messages.MsgAreYouConnectedParm1, ex.Message), Messages.MsgOk);
        }
        finally
        {
            EventHandler handler = SyncAllFinished;
            if (handler != null)
            {
                handler(this, new EventArgs());
            }
            SyncAllFinished -= SynchAllFinishedProcessing;

        }

    }

主要工作方法：

public async Task<bool> LoadCacheDataFromCacheAsync(string dbPath)
    {
        WebSvcManagers.ItemsManager itemsWebServiceManager = new WebSvcManagers.ItemsManager();
        List<Models.WebServiceItems> consumedRecords = new List<Models.WebServiceItems>() { };
        int bufferSize = 100;
        Log.Debug(TAG, "LoadCacheDataFromCacheAsync starting");
        try
        {
            {
                int lastID = 0;
                IEnumerable<Models.WebServiceItems> remoteRecords = await BAL.DataAccessHelper.GetItemsFromGPCacheAsync(App.Login, lastID, bufferSize, itemsWebServiceManager).ConfigureAwait(false);
                while (remoteRecords.Count() != 0)
                {
                    foreach (Models.WebServiceItems remoteItem in remoteRecords)
                    {

                        // DbActionTypes dbAction = (DbActionTypes)remoteItem.DbAction;
                        Models.Items itemRecord = new Models.Items() { ItemNumber = remoteItem.ItemNumber.ToUpper().Trim(), Description = remoteItem.Description.Trim() };
                        Log.Debug(TAG, "Processing {0}", remoteItem.ItemNumber.Trim());

                        bool success = await AddRecordAsync(itemRecord).ConfigureAwait(false);
                        if (success)
                            consumedRecords.Add(remoteItem);

                    }
                    lastID = remoteRecords.Max(r => r.RecordID) + 1;
                    remoteRecords = await BAL.DataAccessHelper.GetItemsFromGPCacheAsync(App.Login, lastID, bufferSize, itemsWebServiceManager).ConfigureAwait(false);
                }

            }
           // await UpdateConsumedRecords(consumedRecords).ConfigureAwait(false);

            return true;
        }
        catch (Exception ex)
        {
            this.StatusMessage = ex.Message;
            Log.Debug(TAG, "Error Catch: {0}", StatusMessage);
            return false;
        }
        finally
        {
            itemsWebServiceManager = null;
            HandleSyncFinished(this, new EventArgs());
            SyncAllFinished -= HandleSyncFinished;
        }
    }

public async任务loadCachedatafromCacheAync（字符串dbPath）
{
WebVCManagers.ItemsManager itemsWebServiceManager=新建WebVCManagers.ItemsManager（）；
List consumedRecords=新列表（）{}；
int bufferSize=100；
Debug（标记“LoadCacheDataFromCacheAxync启动”）；
尝试
{
{
int-lastID=0；
IEnumerable remoteRecords=await BAL.DataAccessHelper.GetItemsFromgpCacheAync（App.Login，lastID，bufferSize，itemsWebServiceManager）。ConfigureAwait（false）；
while（remoteRecords.Count（）！=0）
{
foreach（remoteRecords中的Models.WebServiceItems remoteItem）
{
//DbActionTypes dbAction=（DbActionTypes）remoteItem.dbAction；
Models.Items itemRecord=new Models.Items（）{ItemNumber=remoteItem.ItemNumber.ToUpper（）.Trim（），Description=remoteItem.Description.Trim（）}；
Debug（标记“Processing{0}”，remoteItem.ItemNumber.Trim（））；
bool success=await AddRecordAsync（itemRecord）.ConfigureAwait（false）；
如果（成功）
消费记录。添加（remoteItem）；
}
lastID=remoteRecords.Max（r=>r.RecordID）+1；
remoteRecords=await BAL.DataAccessHelper.GetItemsFromgpCacheAync（App.Login，lastID，bufferSize，itemsWebServiceManager）。ConfigureAwait（false）；
}
}
//等待更新消费记录（消费记录）。配置等待（false）；
返回true；
}
捕获（例外情况除外）
{
this.StatusMessage=示例消息；
调试（标记，“错误捕获：{0}”，StatusMessage）；
返回false；
}
最后
{
itemsWebServiceManager=null；
HandleSyncFinished（这是新的EventArgs（））；
SyncAllFinished-=手动syncfinished；
}
}

我的简单Web服务管理器：

        public static async Task<IEnumerable<Models.WebServiceItems>> GetItemsFromGPCacheAsync(Models.Login login, int offset, int bufferCount, WebSvcManagers.ItemsManager manager)
    {
        try
        {
            return await manager.GetCacheRecordsAsync(login, offset, bufferCount).ConfigureAwait(false);
        }
        catch (Exception)
        {
            throw;
        }
    }

publicstaticasync任务getItemsFromgpCacheAync（Models.Login登录、int offset、int bufferCount、webvcmanagers.ItemsManager）
{
尝试
{
返回wait manager.GetCacheRecordsAsync（登录、偏移、缓冲区计数）.configureWait（false）；
}
捕获（例外）
{
投掷；
}
}

以及与web服务交互的代码：

const int bufferSize = 100;

        public async Task<IEnumerable<Models.WebServiceItems>> GetCacheRecordsAsync(Models.Login login, int offSet, int bufferCount)
    {
        string deviceID = App.ConfigSettings.DeviceID.ToString("D");
        try
        {
            ///* Testing start */
            //return await DataStore(bufferCount, offSet).ConfigureAwait(false);
            ///* Testing end */

            if (!App.IsConnected)
                throw new BAL.Exceptions.NetworkException(Messages.ExceptionNetworkConnection);

            string user = login.UserName;
            string password = login.Password;
            HttpClient client = HttpClientExtensions.CreateHttpClient(user, password);
            try
            {
                List<Models.WebServiceItems> items = new List<Models.WebServiceItems>() { };
                int lastID = offSet;
                int i = 0;
                string uri = string.Format("{0}", string.Format(Messages.WebRequestItemsCacheParms3, deviceID, lastID, Math.Min(bufferCount, bufferSize)));
                Log.Debug(TAG, string.Format("Webservice {0}", uri));
                string response = await client.GetStringAsync(uri).ConfigureAwait(false);
                while (i < bufferCount && response != null && response != "[]")
                {
                    while (response != null && response != "[]")
                    {
                        dynamic array = JsonConvert.DeserializeObject(response);

                        foreach (var item in array)
                        {
                            i++;
                            items.Add(new Models.WebServiceItems()
                            {
                                ItemNumber = item["ITEMNMBR"].Value.Trim(),
                                Description = item["ITEMDESC"].Value.Trim(),
                                DbAction = (int)(item["DbAction"].Value),
                                RecordID = (int)(item["DEX_ROW_ID"].Value),
                            });
                            lastID = (int)(item["DEX_ROW_ID"].Value);
                            Log.Debug(TAG, string.Format("Webservice {0}", item["ITEMNMBR"].Value.Trim()));
                        }
                        if (i < Math.Min(bufferCount, bufferSize))
                        {
                            uri = string.Format("{0}", string.Format(Messages.WebRequestItemsCacheParms3, deviceID, lastID + 1, Math.Min(bufferCount, bufferSize)));
                            Log.Debug(TAG, string.Format("Webservice {0}", uri));
                            response = await client.GetStringAsync(uri).ConfigureAwait(false);
                        }
                        else
                            break;
                    }
                }
                Log.Debug(TAG, string.Format("Webservice return {0} items", items.Count()));
                return items;
            }
            catch (Exception ex)
            {
                Log.Debug(TAG, "Error Catch: {0}", ex.Message);
                throw ex;
            }
        }
        catch (System.Net.Http.HttpRequestException nex)
        {
            throw new Exception(string.Format(Messages.ExceptionWebServiceLoginParm1, nex.Message));
        }
        catch (Exception)
        {
            throw;
        }
    }

const int bufferSize=100；
公共异步任务GetCacheRecordsAsync（Models.Login登录、int偏移量、int缓冲计数）
{
字符串deviceID=App.ConfigSettings.deviceID.ToString（“D”）；
尝试
{
///*测试开始*/
//返回等待数据存储（缓冲计数、偏移量）；
///*测试端*/
如果（！应用程序已断开连接）
抛出新的BAL.Exceptions.NetworkException（Messages.ExceptionNetworkConnection）；
字符串user=login.UserName；
字符串密码=login.password；
HttpClient client=HttpClientExtensions.CreateHttpClient（用户，密码）；
尝试
{
列表项=新列表（）{}；
int lastID=偏移量；
int i=0；
stringuri=string.Format（“{0}”，string.Format（Messages.WebRequestItemsCacheParms3，deviceID，lastID，Math.Min（bufferCount，bufferSize））；
Debug（TAG，string.Format（“Webservice{0}”，uri））；
string response=await client.GetStringAsync（uri）.ConfigureAwait（false）；
而（i08-03 12:41:11.281 D/X:ItemsRepositiory(16980): UpdateRecordAsync 65702-40710 
08-03 12:41:11.306 D/X:ItemsManager(16980): Webservice DeleteCacheRecordAsync 20497 
08-03 12:41:11.406 D/X:ItemsManager(16980): Webservice api/InventoryItems?DeviceID=7c5bb45d-2ea0-45b9-ae50-92f2e25a2983&OffSet=20498&Ma‌​x=100&cached=true 
Thread finished: <Thread Pool> #7 08-03 12:41:11.521 E/art (16980): Nested signal detected - original signal being reported The thread 'Unknown' (0x7) has exited with code 0 (0x0).