Silverlight异步操作Foreach循环

我有一个查询，以获取以下处方列表：

 var PRSCRPTSQuery = GV.dbContext.Load(GV.dbContext.GetPRSCRPTQuery(GV.curCustomer.CustCode,
                                          oOrdritemEdited.ProdCode, oOrdritemEdited.MedCode));
              PRSCRPTSQuery.Completed += new EventHandler(PRSCRPTSQuery_Completed);

在查询完成事件中，我有以下代码：

 void PRSCRPTSQuery_Completed(object sender, EventArgs e)
  {          
      lstPRSCRPT = GV.dbContext.PRSCRPTs.Where(p=>p.Status =="Activated").ToList();
      if (lstPRSCRPT.Count > 0)
      {
          foreach (var rec in lstPRSCRPT)
          {
               var OrderItemQuery = GV.dbContext.Load(GV.dbContext.GetOrdritemsQuery(rec.PresNo));
               OrderItemQuery.Completed += new EventHandler(OrderItemQuery_Completed);               
          }                            
      } 
  }       

列表lstPRSCRPT可以包含多条记录。我推测，foreach循环将前进到循环中的下一项，而不等待OrderItemQuery_Completed事件，如下所示：

  void OrderItemQuery_Completed(object sender, EventArgs e)
  {
      lstOrderItem = GV.dbContext.OrderItems.ToList();
      if (lstOrderItem.Count > 0)
      {
          foreach (var OrdrItemRec in lstOrderItem)
          {
              TotTonnes = (double)(TotTonnes + OrdrItemRec.Quantity);
          }              
      }
   }

---

在这种情况下有什么解决办法吗？我不熟悉SL中的异步编程类型，您可能会发现VS Async CTP非常有趣。它引入了新的“async”关键字来处理异步事件。他在博客中对此进行了解释：

您可能会发现VS Async CTP非常有趣。它引入了新的“async”关键字来处理异步事件。他在博客中解释说：

我知道你来自哪里，当我第一次开始Silverlight编程时，我抓住了我对同步执行的先入之见，所以我知道我调用完一个查询后得到了什么，也知道它的确切错误位置

然而，Silverlight接受了这个概念，并试图从您那里撕下它，大喊“这种方式更好，相信我！”并且为了丰富客户端交互，它肯定成功了。这只是需要时间。您只需要了解更多关于如何将所有内容链接在一起的样式

更快的解决方案之前展示的链接显示了C#在异步编码方面的发展方向，但知道它实际为您完成了什么是值得的。在问题中链接的代码中，您已经掌握了其中的一些

当我遇到相同的情况时，背对背异步回调是在我完成所做的事情后引发一个事件。例如：

public event EventHandler<EventArgs> LoadComplete;
public int QueryCount {get;set;}
public int QuerysCompleted {get;set;}

public void GetItems()
{
    var PRSCRPTSQuery = GV.dbContext.Load(GV.dbContext.GetPRSCRPTQuery
        (GV.curCustomer.CustCode, oOrdritemEdited.ProdCode, oOrdritemEdited.MedCode));
    PRSCRPTSQuery.Completed += new EventHandler(PRSCRPTSQuery_Completed);
    LoadComplete += loader_LoadComplete;
}


void PRSCRPTSQuery_Completed(object sender, EventArgs e)
{          
  lstPRSCRPT = GV.dbContext.PRSCRPTs.Where(p=>p.Status =="Activated").ToList();
  if (lstPRSCRPT.Count > 0)
  {
      QueryCount = lstPRSCRPT.Count;
      foreach (var rec in lstPRSCRPT)
      {
           var OrderItemQuery = GV.dbContext.Load(GV.dbContext.GetOrdritemsQuery(rec.PresNo));
           OrderItemQuery.Completed += new EventHandler(OrderItemQuery_Completed);               
      }                            
  } 

 }

  void OrderItemQuery_Completed(object sender, EventArgs e)
  {
      QueryCompleted++;
      lstOrderItem = GV.dbContext.OrderItems.ToList();
      if (lstOrderItem.Count > 0)
      {
          foreach (var OrdrItemRec in lstOrderItem)
          {
              TotTonnes = (double)(TotTonnes + OrdrItemRec.Quantity);
          }              
      }

     if(QueryCompleted == QueryCount)
     {
         RaiseLoadComplete();
     } 
  }



 public void RaiseLoadComplete()
 {
      if(LoadComplete != null)
      {
           LoadComplete(this, new EventArgs());
      }
 }


 void loader_LoadComplete(object sender, EventArgs e)
 {
      //Code to execute here
 }    

公共事件事件处理程序加载完成；
公共int查询计数{get；set；}
public int querycompleted{get；set；}
公共项目（）
{
var PRSCRPTSKERY=GV.dbContext.Load（GV.dbContext.GetPRSCRPTQuery
（GV.curCustomer.CustCode、oOrdritemEdited.ProdCode、oOrdritemEdited.MedCode））；
PRSCRPTSQuery.Completed+=新事件处理程序（PRSCRPTSQuery_Completed）；
LoadComplete+=装载机\装载完成；
}
无效PRSCRPTSKERY_已完成（对象发送方，事件参数e）
{          
lstPRSCRPT=GV.dbContext.PRSCRPTs.Where（p=>p.Status==“已激活”）.ToList（）；
如果（lstPRSCRPT.Count>0）
{
QueryCount=lstPRSCRPT.Count；
foreach（LSTPRSRCPT中的var rec）
{
var OrderItemQuery=GV.dbContext.Load（GV.dbContext.GetOrdritemsQuery（rec.PresNo））；
OrderItemQuery.Completed+=新事件处理程序（OrderItemQuery\u Completed）；
}                            
} 
}
无效OrderItemQuery_已完成（对象发送方，事件参数e）
{
QueryCompleted++；
lstOrderItem=GV.dbContext.OrderItems.ToList（）；
如果（lstOrderItem.Count>0）
{
foreach（lstOrderItem中的var OrdrItemRec）
{
总吨=（双倍）（总吨+订单数量）；
}              
}
if（QueryCompleted==QueryCount）
{
RaiseLoadComplete（）；
} 
}
公共无效RaiseLoadComplete（）
{
if（LoadComplete！=null）
{
LoadComplete（这是新的EventArgs（））；
}
}
无效加载程序\加载完成（对象发送器，事件参数e）
{
//要在此处执行的代码
}    

我在启动第一个查询时附加一个事件，查询完成后要执行的代码。在第一次查询回调中，我初始化了一个计数，计算出我期望的响应数量。然后在第二次查询回调中，我递增，直到得到正确的数量，并调用事件来表示im done

---

这种方法唯一需要注意的是，如果其中一个查询出错，最终代码将永远不会执行

我知道你从哪里来，当我第一次开始Silverlight编程时，我抓住了我对同步执行的先入之见，所以我知道我调用完一个查询后得到了什么，也知道它的确切错误位置

然而，Silverlight接受了这个概念，并试图从您那里撕下它，大喊“这种方式更好，相信我！”并且为了丰富客户端交互，它肯定成功了。这只是需要时间。您只需要了解更多关于如何将所有内容链接在一起的样式

更快的解决方案之前展示的链接显示了C#在异步编码方面的发展方向，但知道它实际为您完成了什么是值得的。在问题中链接的代码中，您已经掌握了其中的一些

当我遇到相同的情况时，背对背异步回调是在我完成所做的事情后引发一个事件。例如：

public event EventHandler<EventArgs> LoadComplete;
public int QueryCount {get;set;}
public int QuerysCompleted {get;set;}

public void GetItems()
{
    var PRSCRPTSQuery = GV.dbContext.Load(GV.dbContext.GetPRSCRPTQuery
        (GV.curCustomer.CustCode, oOrdritemEdited.ProdCode, oOrdritemEdited.MedCode));
    PRSCRPTSQuery.Completed += new EventHandler(PRSCRPTSQuery_Completed);
    LoadComplete += loader_LoadComplete;
}


void PRSCRPTSQuery_Completed(object sender, EventArgs e)
{          
  lstPRSCRPT = GV.dbContext.PRSCRPTs.Where(p=>p.Status =="Activated").ToList();
  if (lstPRSCRPT.Count > 0)
  {
      QueryCount = lstPRSCRPT.Count;
      foreach (var rec in lstPRSCRPT)
      {
           var OrderItemQuery = GV.dbContext.Load(GV.dbContext.GetOrdritemsQuery(rec.PresNo));
           OrderItemQuery.Completed += new EventHandler(OrderItemQuery_Completed);               
      }                            
  } 

 }

  void OrderItemQuery_Completed(object sender, EventArgs e)
  {
      QueryCompleted++;
      lstOrderItem = GV.dbContext.OrderItems.ToList();
      if (lstOrderItem.Count > 0)
      {
          foreach (var OrdrItemRec in lstOrderItem)
          {
              TotTonnes = (double)(TotTonnes + OrdrItemRec.Quantity);
          }              
      }

     if(QueryCompleted == QueryCount)
     {
         RaiseLoadComplete();
     } 
  }



 public void RaiseLoadComplete()
 {
      if(LoadComplete != null)
      {
           LoadComplete(this, new EventArgs());
      }
 }


 void loader_LoadComplete(object sender, EventArgs e)
 {
      //Code to execute here
 }    

公共事件事件处理程序加载完成；
公共int查询计数{get；set；}
public int querycompleted{get；set；}
公共项目（）
{
var PRSCRPTSKERY=GV.dbContext.Load（GV.dbContext.GetPRSCRPTQuery
（GV.curCustomer.CustCode、oOrdritemEdited.ProdCode、oOrdritemEdited.MedCode））；
PRSCRPTSQuery.Completed+=新事件处理程序（PRSCRPTSQuery_Completed）；
LoadComplete+=装载机\装载完成；
}
无效PRSCRPTSKERY_已完成（对象发送方，事件参数e）
{          
lstPRSCRPT=GV.dbContext.PRSCRPTs.Where（p=>p.Status==“已激活”）.ToList（）；
如果（lstPRSCRPT.Count>0）
{
QueryCount=lstPRSCRPT.Count；
foreach（LSTPRSRCPT中的var rec）
{
var OrderItemQuery=GV.dbContext.Load（GV.dbContext.GetOrdritemsQuery（rec.PresNo））；
OrderItemQuery.Completed+=新事件处理程序（OrderItemQuery\u Completed）；
}                            
} 
}
无效OrderItemQuery_已完成（对象发送方，事件参数e）
{
QueryCompleted++；
lstOrderItem=GV.dbContext.OrderItems.ToList（）；
如果（lstOrderItem.Count>0）
{
foreach（lstOrderItem中的var OrdrItemRec）
{
总吨=（双倍）（总吨+订单数量）；
}              
}