巨大なデータを持つネストされたforeachメモリ不足例外が発生しました

Question

私はマシンから返されたデータを扱っています。大規模な農場で通常使用されているマシンで、さまざまな深度の各ポイントでさまざまなデバイスを使用してデータを収集します。

各ファームはここ70〜100個のフィールドと、各フィールドは約10万人のデータが含まれてい

を含むことができ、私はそれぞれのデータを処理し、クライアントの要件に基づいていくつかの計算を適用する必要があります。

ファームでフィールドを繰り返し、次にファームのフィールドを作成し、ファームごとにデバイスを使用して、深さに基づいて各デバイスのレコードを作成する必要があります。 最後に、私は約10億回の反復をしたいと思います。 私のコードは

public async void MigrateData() 
     { 
      masterData = await CatalogService.ExportMasterData(AppDataModel.Catalog, this.UserId); 

      foreach (var fieldItem in masterData.Fields) 
      { 
       var fieldReferenceId = fieldItem.ReferenceId; 

       dynamic loggedData = AppDataModel.Documents.LoggedData.Where(data => data.FieldId == fieldReferenceId); 
       dynamic fieldDbMappingData = fieldItem; 

       foreach (var data in loggedData) 
       { 
        yieldMaster.OperationalLogModalResponse = await YieldDataMigrationService.AddOperationalLogs("loggedDataDescription"); 
        yieldMaster.OperationalLogDataModelResponse = await YieldDataMigrationService.AddOperationalLogData(fieldDbMappingData, yieldMaster.OperationalLogModalResponse); 

        FetchContentData(data); 

       } 

      } 

     } 
private async void FetchContentData(LoggedData data) 
     { 

      foreach (var opdata in data.OperationData) 
      { 
       var filteredList = AggregateDataBasedOnFilter(opdata); 

       int count = filteredList.Count; 
       totalRecordCount += count; 
       for (int i = 1; i <= count; i = i + 1000) 
       { 
        var response = await YieldDataMigrationService.AddYiledData(filteredList.GetRange(i, i + 1000 >= count ? count - i : 1000)); 

       } 
      } 
      //Filter data based on timestamp values , get the first data in 5 seconds interval 

      System.GC.Collect(); 
     } 

private dynamic AggregateDataBasedOnFilter(OperationData opdata) 
     { 
      List<dynamic> listSpacialRecords = new List<dynamic>(); 
      IEnumerable<SpatialRecord> spacialRecords = opdata.GetSpatialRecords(); 
      spacialRecords = GetAggregateBasedOnTimeStamb(spacialRecords); 
      Nullable<Guid> productid; 
      for (int depth = 0; depth <= opdata.MaxDepth; depth++) 
      { 
       IEnumerable<DeviceElementUse> deviceElementUses = opdata.GetDeviceElementUses(depth); 
       StevProduct productDbMappingData = masterData.Products.Where(product => product.ReferenceId == opdata.ProductId).FirstOrDefault(); 
       if (productDbMappingData == null) 
       { 
        productid = null; 
       } 
       else 
       { 
        productid = productDbMappingData.Id; 
       } 
       foreach (var deviceElement in deviceElementUses) 
       { 

        List<dynamic> dvList = new List<dynamic>(); 
        IEnumerable<WorkingData> workingData = deviceElement.GetWorkingDatas(); 

        //foreach (var spacerecord in spacialRecords) 
        Parallel.ForEach(spacialRecords, (spacerecord) => 
        { 
         List<MeterValue> dat = new List<MeterValue>(); 
         var latitude = ((AgGateway.ADAPT.ApplicationDataModel.Shapes.Point)spacerecord.Geometry).Y; 
         var longitude = ((AgGateway.ADAPT.ApplicationDataModel.Shapes.Point)spacerecord.Geometry).X; 
         var timeStamp = spacerecord.Timestamp; 
         //Parallel.ForEach(workingData, (wdItem) => 
         foreach (var wdItem in workingData) 
         { 
          RepresentationValue spaceMeteredValue = spacerecord.GetMeterValue(wdItem); 
          if (spaceMeteredValue != null && wdItem.Representation != null) 
          { 
           //row[wdItem.Representation.Code] = meteredValue.Value.Value; 
           var objMeterValue = new MeterValue(); 
           objMeterValue.key = wdItem.Representation.Code; 
           objMeterValue.value = spaceMeteredValue.Designator != null ? Convert.ToString(spaceMeteredValue.Designator) : ""; 
           dat.Add(objMeterValue); 
          } 
         } 
         var newSpacialvalue = new 
         { 
          operationLogDataId = yieldMaster.OperationalLogDataModelResponse.Id, 
          order = deviceElement.Order, 
          totalDistanceTravelled = deviceElement.TotalDistanceTravelled, 
          totalElapsedTime = deviceElement.TotalElapsedTime, 
          uploadedOn = DateTime.Now.ToUniversalTime(), 
          collectedOn = timeStamp.ToUniversalTime(), 
          cropId = "8296e610-c055-11e7-851e-ad7650a5f99c", 
          productId = productid, 
          latitude = latitude, 
          longitude = longitude, 
          deviceConfigurationId = deviceElement.DeviceConfigurationId, 
          operationDataId = deviceElement.OperationDataId, 
          spatialRecords = dat, 
          depth = depth, 
          timeStamp = timeStamp, 
          totaldata = totalRecordCount 
         }; 
         lock (listSpacialRecords) 
         { 
          listSpacialRecords.Add(newSpacialvalue); 
         } 

        }); 


       } 
      } 

      listSpacialRecords = listSpacialRecords 
        .Skip(1) 
        .Aggregate(
         listSpacialRecords.Take(1).ToList(), 
         (a, x) => 
         { 
          if (x.timeStamp.Subtract(a.Last().timeStamp).TotalSeconds >= 10.0) 
          { 
           a.Add(x); 
          } 
          return a; 
         }); 
      GC.Collect(); 
      return listSpacialRecords; 

     } 

私の本当のシナリオはこれよりもっと複雑である下回るように見えます。それは多くのforeachと計算があります。全体のプロセスは30分以上実行されています。しかし、その間に私はメモリから外れています 例外。この非常に巨大なデータをどう扱うかは考えていません。

誰でもネストされたforeachよりも優れたアプローチをしていますか？または、メモリを避けるためのソリューション？

注：別々の機能で各ルックを移動しましたが、まだメモリ不足が表示されています。また、私はロジックセクションで計算されたデータを扱うローカルリストを持っています。ローカルリストこれはグローバルオブジェクトではありません

Answer 1

プネーネはコメントで「OutOfMemoryは発生していません。大規模なセットに対して反復処理を行っているためですが、そのデータを一時的な変数に保存していて、いくつかの設定された数のチェックの後で明示的なガベージコレクションを行うべきだと思います。 "

必要がないときに手動で要素を配置する方が良いでしょう。

{object}.Dispose(); 

または、ガベージコレクションステートメントをすべてのループの最後に配置します。

GC.Collect(); 

また、シリアル/キュムル操作でない場合は、Parallel.Foreachを使用してパフォーマンスを向上させることができます。