How to sum list<double> of the same index with in the dictionary

Provided the count of each dictionary Values should be same.

try this.

List<double> sum = new List<double>();
          int count = dictionary.ToList().First().Value.Count;
          for (int i = 0; i < count; i++)
          {
              double temp = 0;
              foreach (List<double> items in dictionary.Values)
                  temp += items[i];
              sum.Add(temp);

          }

updated solution:
the below code will take care, irespective of items count in each value of dictionary.

List<double> sum = new List<double>();
           int maxCount = dictionary.Values.ToList().Max(k => k.Count);
           for (int i = 0; i < maxCount; i++)
           {
               double temp = 0;
               foreach (List<double> items in dictionary.Values)
                   if (i < items.Count)
                       temp += items[i];
               sum.Add(temp);

           }

A slightly different way of doing what Karthik demonstrates here, showing the use of the 'yield iterator pattern:

Dictionary<int, List<double>> intdbl = new Dictionary<int, List<double>>
{
    {1, new List<double>{1.0,2.0,3.0}},
    {2, new List<double>{56.0,21.0,323.0}}
};

IEnumerable<double> listSums(List<List<double>> lstValues)
{
    // no lists : quit
    if (lstValues.Count == 0) yield break;

    // like Karthik I assume that the first list
    // item count is what to use ...
    int repcount = lstValues[0].Count;

    // no items : quit
    if (repcount == 0) yield break;

    // select only those lists that have the same number of items
    var okayvalues = lstValues.Where(lst => lst.Count == repcount);

    // this should not happen ... but ...
    if (okayvalues.Count() == 0) 
    {
        yield break;
    }

    for (int i = 0; i < repcount; i++)
    {
        yield return
            (okayvalues.Select(lst => lst[i]).Sum());
    }
}


// test in some method or EventHandler
// IEnumerable<double> is returned
var test = listSums(intdbl.Values.ToList());</double>

The issue of what you can reliably assume is true about the state of the data you deal with here is ... critical. The above example would work with Dictionaries where the values (lists of double) are of any size, but, you can see that if you base the number of values to use on just the first list ... you have made an assumption that may come back to haunt you.

Assuming that you always want to have a number of "totals" equal to the size of the largest dictionary value (list of doubles), actually makes it simpler, imho, to program:

Dictionary<int, List<double>> intdbl = new Dictionary<int, List<double>>
{
    {1, new List<double>{1.0,2.0,3.0}},
    {2, new List<double>{56.0,21.0,323.0}},
    {3, new List<double>{22.23, 12.435, 99.332, 120.453, 0.993}}
};

// test in a method or EventHandler

// get the size of the largest list in 'Value Collection
int maxlistsize = intdbl.Values.ToList()
    .Select(itm => itm.Count).Max();

// allocate a new list of doubles with 'maxlistsize
// and fill it with 0.0's
List<double> totals = new List<double>(maxlistsize);
totals.AddRange(Enumerable.Repeat(0d, maxlistsize));

foreach (List<double> dbllist in intdbl.Values)
{
    for (int i = 0; i < dbllist.Count; i++)
    {
        totals[i] += dbllist[i];
    }
}

// Result:

> ? totals
Count = 5
    [0]: 79.23
    [1]: 35.435
    [2]: 425.332
    [3]: 120.453
    [4]: 0.993</double></double></double>

The question remains however: what is your requirement here for structural consistency of the data ? When your code is used, what can you assume about the data, and what do those assumptions require to do in code to prevent errors and get "meaningful" results.

In addition to already posted answers, i'd like to add Linq solution (even if it may cause performance issues for huge amount of data).

Try this:

Dictionary<int, List<double>> dicendingvalue = new Dictionary<int, List<double>>();
dicendingvalue.Add(1, new List<double>() { 2, 3, 5 }); //3 items!
dicendingvalue.Add(2, new List<double>() { 5, 8, 4, 10}); //4 items!

var resultlist = dicendingvalue
				.SelectMany(x=>x.Value.Select((a,b) => new{index=b, value=a}))
				.GroupBy(x=>x.index)
				.Select(grp=>new{index = grp.Key, sov = grp.Sum(a=>a.value)})
				.ToList();

Using Tuple[^]:

var resultlist1 = dicendingvalue
				.SelectMany(x=>x.Value.Select((a,b) => Tuple.Create(b, a)))
				.GroupBy(x=>x.Item1)
				.Select(grp=>new{index = grp.Key, sov = grp.Sum(a=>a.Item2)})
				.ToList();

As you can see, the count of items in List<double> may differ, but the result is always good ;)

index  sov 
0       7 
1       11 
2       9 
3       10