Sommare i valori attraverso gli elenchi annidati in ciascun indice

Question

Ho un List<List<string>> chiamato _DataCollection in cui ciascuno degli elenchi nidificati ha un numero uguale di valori. Sebbene tutte le stringhe, i valori negli elenchi nidificati siano stringhe costituite da caratteri alfanumerici, stringhe vuote o un valore di valuta. Per esempio

_DataCollection[0] = {"tom", "abc", "$525.34", "$123"} 
_DataCollection[1] = {"dick", "xyz", "$100", "$234"} 
_DataCollection[2] = {"harry", "", "$250.01", "$40"} 
_DataCollection[2] = {"bob", "", "$250.01", ""} 

Che cosa devo fare è trovare un modo per riassumere tutti i valori per indice in tutte le liste nidificate e aggiungere questo a un elenco:

newSumList[0] = "N/A" since "tom" + "dick" + "harry" + "bob" can't be aggregated. 
newSumList[1] = "N/A" since "abc" + "xyz" + "" + "" can't be aggregated. 
newSumList[2] = "1125.36" 
newSumList[3] = "397" even though the last value of the last nested list is "". 

In sostanza, in totale tutte numerico valori negli elenchi annidati per ogni indice.

L'unico modo in cui riesco a pensare è quello di ripetere questi e mantenere un totale parziale, ma mi chiedevo se posso farlo usando LINQ o qualcos'altro.

Answer 1

Ecco qui.

var list = new List<List<string>> 
{ 
    new List<string> {"tom", "abc", "$525.34", "$123"}, 
    new List<string> {"dick", "xyz", "$100", "$234"}, 
    new List<string> {"harry", "", "$250.01", "$40"}, 
    new List<string> {"bob", "", "$250.01", ""} 
}; 

decimal num; 
var itemsPerLine = list[0].Count; // 4 
var res = list.SelectMany(line => line); 
       .Select((s, i) => new { Text = s, Index = i }) 
       .GroupBy(i => i.Index % itemsPerLine) // transformed matrix here 
       .Select(g => g.Sum(i => 
        decimal.TryParse(i.Text, NumberStyles.AllowCurrencySymbol | 
              NumberStyles.AllowDecimalPoint, 
              new CultureInfo("en-US"), out num) 
              ? num : 0)); 

È possibile, ovviamente, specificare cosa dovrebbe essere riconosciuto come un numero cambiando NumberStyles bandiere e informazioni cultura.

Answer 2

List<List<string>> _DataCollection=new List<List<string>>(); 
      _DataCollection.Add(new List<string> {"tom", "abc", "$525.34", "$123"}); 

      _DataCollection.Add(new List<string> {"dick", "xyz", "$100", "$234"}); 
      _DataCollection.Add(new List<string> {"harry", "", "$250.01", "$40"}); 
      _DataCollection.Add(new List<string> {"bob", "", "$250.01", ""}); 

      List<string> newSumList = new List<string>(); 

      for (int i = 0; i < _DataCollection.Count; i++) 
      { 
       decimal Sum = 0; 
       string CurrentSumList; 
       string Comment; 
       decimal amount = 0; 
       for (int j = 0; j < _DataCollection.Count; j++) 
       { 
        bool IsDecimalAmount=decimal.TryParse(_DataCollection[j][i].Replace('$','0'),out amount); 
        if (IsDecimalAmount) 
        { 

         Sum += amount; 
        } 
        else 
        { 
         Comment = "String"; 

        } 
       } 
       CurrentSumList = Sum.ToString(); 
       newSumList.Add(CurrentSumList); 
      } 

ho implementato questo & mi dà il risultato.

Answer 3

Prova questa: -

decimal _temp =0; 
int ListLength = _DataCollection.First().Count(); 
      var query = _DataCollection.SelectMany(x => x). 
             Select((v, i) => new { Val = v, Index = i % ListLength }) 
             .GroupBy(x => x.Index) 
             .Select(z => z.Sum(y => decimal.TryParse(y.Val,out _temp) ? _temp : 0)); 

lavoro Fiddle.

Answer 4

// Replace $value with value and remove all non-value strings 
var dollars = _DataCollection 
    .Select(l => l.Select(str => str.Contains('$') ? str.Split('$')[1] : string.Empty)); 

var newSumList = new List<double>(); 

// Add all values in a new list 
for (int i = 0; i < _DataCollection[0].Count; i++) 
{ 
    double toAdd = 0; 
    foreach (var entry in dollars) 
    { 
     // If entry is a value, parse it, 0 otherwise 
     var value = entry.ElementAt(i) != string.Empty ? double.Parse(entry.ElementAt(i)) : 0; 
     toAdd = toAdd + value; 
    } 
    newSumList.Add(toAdd); 
} 
newSumList.ForEach(Console.WriteLine); 

Answer 5

Oppure, per un approccio diverso che non richiede riordinare le sequenze con GroupBy:

 var culture = new CultureInfo("en-US"); 
     List<string> sums = 
      _DataCollection.Count == 0 
      ? new List<string>() 
      : Enumerable.Range(0, _DataCollection.First().Count) 
      .Select(i => _DataCollection.Select(list => list[i]) 
         .Select(s => { decimal val; return string.IsNullOrEmpty(s) ? (decimal?)0 : decimal.TryParse(s, NumberStyles.Currency, culture, out val) ? (decimal?)val : (decimal?)null; }) 
         .Aggregate((decimal?)0, (sum, val) => sum + val)) 
      .Select(sum => sum.HasValue ? sum.Value.ToString(culture) : "N/A") 
      .ToList(); 

Answer 6

senza scorrere più volte e supportare elenchi sorgente vuoti

var list = new List<string[]> 
{ 
    new [] {"tom", "abc", "$525.34", "$123"}, 
    new [] {"dick", "xyz", "$100", "$234"}, 
    new [] {"harry", "", "$250.01", "$40"}, 
    new [] {"bob", "", "$250.01", ""} 
}; 
var cutlure = new CultureInfo("en-US"); 
var result = list.Aggregate((decimal[])null, (sums, strings) => 
    { 
     if (sums == null) 
      sums = Enumerable.Repeat(decimal.MinValue, strings.Length).ToArray(); 
     for (int i = 0; i < strings.Length; i++) 
     { 
      decimal value; 
      if (decimal.TryParse(strings[i], NumberStyles.Currency, cutlure, out value)) 
       sums[i] = (sums[i] == decimal.MinValue) ? value : sums[i] + value; 
     } 
     return sums; 
    }, 
    sums => sums.Select(sum => (sum == decimal.MinValue) ? "N/A" : sum.ToString()).ToArray());